Side tables annotating an instruction stream

ABSTRACT

A microprocessor chip, and methods for use in that microprocessor chip. The chip has instruction pipeline circuitry and address translation circuitry. Table lookup circuitry indexes into a table, the table having an entry associated with each corresponding address range translated by the address translation circuitry. Each entry of the table describes a likelihood of the existence of an alternate coding of instructions located in the respective corresponding address range. The table lookup circuitry retrieves a table entry corresponding to the address, and is operable as part of the basic instruction cycle of executing an instruction of a non-supervisor mode program executing on a computer. Interrupt circuitry is cooperatively designed with the instruction pipeline circuitry to trigger an interrupt on execution of an instruction of a process, synchronously based at least in part on a memory state of the computer and the address of the instruction, the architectural definition of the instruction not calling for an interrupt. A handler for the interrupt is responsive to the contents of the table to affect the instruction pipeline circuitry to effect control of an architecturally-visible data manipulation behavior or control transfer behavior of the instruction based on the contents of a table entry associated with the instruction.

This application is a continuation of U.S. application Ser. No.09/385,394, filed Aug. 30, 1999, which is a continuation-in-part (C-I-P)of application Ser. No. 09/322,443, filed May 28, 1999, which is acontinuation-in-part (C-I-P) of application Ser. No. 09/239,194, filedJan. 28, 1999, which are incorporated herein by reference.

BACKGROUND

The invention relates to execution of instructions for a computer of afirst computer architecture on a computer of a second, differentarchitecture.

Each instruction for execution by a computer is represented as a binarynumber stored in the computer's memory. Each different architecture ofcomputer represents instructions differently. For instance, when a giveninstruction, a given binary number, is executed by an IBM System/360computer, an IBM System/38, an IBM AS/400, an IBM PC, and an IBMPowerPC, the five computers will typically perform five completelydifferent operations, even though all five are manufactured by the samecompany. This correspondence between the binary representation of acomputer's instructions and the actions taken by the computer inresponse is called the Instruction Set Architecture (ISA).

A program coded in the binary ISA for a particular computer family isoften called simply “a binary.” Commercial software is typicallydistributed in binary form. The incompatibility noted in the previousparagraph means that programs distributed in binary form for onearchitecture generally do not run on computers of another. Accordingly,computer users are extremely reluctant to change from one architectureto another, and computer manufacturers are narrowly constrained inmodifying their computer architectures.

A computer most naturally executes programs coded in its native ISA, theISA of the architectural family for which the computer is a member.Several methods are known for executing binaries originally coded forcomputers of another, non-native, ISA. In hardware emulation, thecomputer has hardware specifically directed to executing the non-nativeinstructions. Emulation is typically controlled by a mode bit, anelectronic switch: when a non-native binary is to be executed, a specialinstruction in the emulating computer sets the mode bit and transferscontrol to the non-native binary. When the non-native program exits, themode bit is reset to specify that subsequent instructions are to beinterpreted by the native ISA. Typically, in an emulator, native andnon-native instructions are stored in different address spaces. A secondalternative uses a simulator (also sometimes known as an “interpreter”),a program running on the computer that models a computer of thenon-native architecture. A simulator sequentially fetches instructionsof the non-native binary, determines the meaning of each instruction inturn, and simulates its effect in a software model of the non-nativecomputer. Again, a simulator typically stores native and non-nativeinstructions in distinct address spaces. (The terms “emulation” and“simulation” are not as uniformly applied throughout the industry asmight be suggested by the definitions implied here.) In a thirdalternative, binary translation, a translator program takes thenon-native binary (either a whole program or a program fragment) asinput, and processes it to produce as output a corresponding binary inthe native instruction set (a “native binary”) that runs directly on thecomputer.

Typically, an emulator is found in a newer computer for emulation of anolder computer architecture from the same manufacturer, as a transitionaid to customers. Simulators are provided for the same purpose, and alsoby independent software vendors for use by customers who simply wantaccess to software that is only available in binary form for a machinethat the customer does not own. By whatever technique, non-nativeexecution is slower than native execution, and a non-native program hasaccess to only a portion of the resources available to a native program.

Known methods of profiling the behavior of a computer or of a computerprogram include the following. In one known profiling method, theaddress range occupied by a program is divided into a number of ranges,and a timer goes off from time to time. A software profile analyzerfigures out the address at which the program was executing, andincrements a counter corresponding to the range that embraces theaddress. After a time, the counters will indicate that some ranges areexecuted a great deal, and some are barely executed at all. In anotherknown profiling method, counters are generated into the binary text of aprogram by the compiler. These compiler-generated counters may count thenumber of times a given region is executed, or may count the number oftimes a given execution point is passed or a given branch is taken.

SUMMARY

In general, in a first aspect, the invention features a computer with aninstruction processor designed to execute instructions of first andsecond instruction sets, a memory for storage of a program, a table ofentries corresponding to the pages, a switch, a transition handler, anda history record. The memory is divided into pages for management by avirtual memory manager. The program is coded in instructions of thefirst and second instruction sets and uses first and second data storageconventions. The switch is responsive to a first flag value stored ineach table entry, and controls the instruction processor to interpretinstructions under, alternately, the first or second instruction set asdirected by the first flag value of the table entry corresponding to aninstruction's memory page. The transition handler is designed torecognize when program execution has transferred from a page ofinstructions using the first data storage convention to a page ofinstructions using the second data storage convention, as indicated bysecond flag values stored in table entries corresponding to therespective pages, and in response to the recognition, to adjust a datastorage configuration of the computer from the first storage conventionto the second data storage convention. The history record is designed toprovide to the transition handler a record of a classification of arecently-executed instruction.

In a second aspect, the invention features a method, and a computer forperformance of the method. Instruction data are fetched from first andsecond regions of a single address space of the memory of a computer.The instructions of the first and second regions are coded for executionby computer of first and second architectures or following first andsecond data storage conventions, respectively. The memory regions haveassociated first and second indicator elements, the indicator elementseach having a value indicating the architecture or data storageconvention under which instructions from the associated region are to beexecuted. When execution of the instruction data flows from the firstregion to the second, the computer is adapted for execution in thesecond architecture or convention.

In a third aspect, the invention features a method, and a computer forperformance of the method. Instructions are stored in pages of acomputer memory managed by a virtual memory manager. The instructiondata of the pages are coded for execution by, respectively, computers oftwo different architectures and/or under two different executionconventions. In association with pages of the memory are storedcorresponding indicator elements indicating the architecture orconvention in which the instructions of the pages are to be executed.Instructions from the pages are executed in a common processor, theprocessor designed, responsive to the page indicator elements, toexecute instructions in the architecture or under the conventionindicated by the indicator element corresponding to the instruction'spage.

In a fourth aspect, the invention features a microprocessor chip. Aninstruction unit of the chip is configured to fetch instructions from amemory managed by the virtual memory manager, and configured to executeinstructions coded for first and second different computer architecturesor coded to implement first and second different data storageconventions. The microprocessor chip is designed (a) to retrieveindicator elements stored in association with respective pages of thememory, each indicator element indicating the architecture or conventionin which the instructions of the page are to be executed, and (b) torecognize when instruction execution has flowed from a page of the firstarchitecture or convention to a page of the second, as indicted by therespective associated indicator elements, and (c) to alter a processingmode of the instruction unit or a storage content of the memory toeffect execution of instructions in accord with the indicator elementassociated with the page of the second architecture or convention.

In a fifth aspect, the invention features a method, and a microprocessorcapable of performing the method. A section of computer object code isexecuted twice, without modification of the code section between the twoexecutions. The code section materializes a destination address into aregister and is architecturally defined to directly transfer controlindirectly through the register to the destination address. The twoexecutions materialize two different destination addresses, and the codeat the two destinations is coded in two different instruction sets.

In a sixth aspect, the invention features a method and a computer forthe performance of the method. Control-flow instructions of thecomputer's instruction set are classified into a plurality of classes.During execution of a program on the computer, as part of the executionof instructions of the instruction set, a record is updated to recordthe class of the classified control-flow instruction most recentlyexecuted.

In a seventh aspect, the invention features a method and a computer forthe performance of the method. A control-transfer instruction isexecuted that transfers control from a source execution context to adestination instruction for execution in a destination executioncontext. Before executing the destination instruction, the storagecontext of the computer is adjusted to reestablish under the destinationexecution context the logical context of the computer as interpretedunder the source execution context. The reconfiguring is determined, atleast in part, by a classification of the control-transfer instruction.

In general, in an eighth aspect, the invention features a method ofoperating a computer. Concurrent execution threads are scheduled by apre-existing thread scheduler of a computer. Each thread has anassociated context, the association between a thread and a set ofcomputer resources of the context being maintained by the threadscheduler. Without modifying the thread scheduler, an association ismaintained between one of the threads and an extended context of thethread through a context change induced by the thread scheduler, theextended context including resources of the computer beyond thoseresources whose association with the thread is maintained by the threadscheduler.

In a ninth aspect, the invention features a method of operating acomputer. An entry exception is established, to be raised on each entryto an operating system of a computer at a specified entry point or on aspecified condition. A resumption exception is established, to be raisedon each resumption from the operating system following on a specifiedentry. On detecting a specified entry to the operating system from aninterrupted process of the computer, the entry exception is raised andserviced. The resumption exception is raised and serviced, and controlis returned to the interrupted process.

In a tenth aspect, the invention features a method of operating acomputer. Without modifying an operating system of the computer, anentry handler is established for execution at a specified entry point oron a specified entry condition to the operating system. The entryhandler is programmed to save a context of an interrupted thread and tomodify the thread context before delivering the modified context to theoperating system. Without modifying the operating system, an exithandler is established for execution on resumption from the operatingsystem following an entry through the entry handler. The exit handler isprogrammed to restore the context saved by a corresponding execution ofthe entry handler.

In an eleventh aspect, the invention features a method of operating acomputer. During invocation of a service routine of a computer, alinkage return address passed, the return address being deliberatelychosen so that an attempt to execute an instruction from the returnaddress on return from the service routine will cause an exception toprogram execution. On return from the service routine, the chosenexception is raised. After servicing the exception, control is returnedto a caller of the service routine.

Particular embodiments of the invention may include one or more of thefollowing features. The regions may be pages managed by a virtual memorymanager. The indications may be stored in a virtual address translationentry, in a table whose entries are associated with correspondingvirtual pages, in a table whose entries are associated withcorresponding physical page frames, in entries of a translationlook-aside buffer, or in lines of an instruction cache. The code at thefirst destination may receive floating-point arguments and returnfloating-point return values using a register-based calling convention,while the code at the second destination receives floating-pointarguments using a memory-based stack calling convention, and returnsfloating-point values using a register indicated by a top-of-stackpointer.

The two architectures may be two instruction set architectures, and theinstruction execution hardware of the computer may be controlled tointerpret the instructions according to the two instruction setarchitectures according to the indications. A mode of execution of theinstructions may be changed without further intervention when executionflows from the first region to the second, or the mode may be changed byan exception handler when the computer takes an exception when executionflows from the first region to the second. One of the regions may storean off-the-shelf operating system binary coded in an instruction setnon-native to the computer.

The two conventions may be first and second calling conventions, and thecomputer may recognize when program execution has transferred from aregion using the first calling convention to a region using the secondcalling convention, and in response to the recognition, the data storageconfiguration of the computer will be adjusted from the first callingconvention to the second. One of the two calling conventions may be aregister-based calling convention, and the other calling convention maybe a memory stack-based calling convention. There may be a definedmapping between resources of the first architecture and resources of thesecond, the mapping assigning corresponding resources of the twoarchitectures to a common physical resource of a computer when theresources serve analogous functions in the calling conventions of thetwo architectures. The configuration adjustment may include altering abit representation of a datum from a first representation to a secondrepresentation, the alteration of representation being chosen topreserve the meaning of the datum across the change in executionconvention. A rule for copying data from the first location to thesecond may be determined, at least in part, by a classification of theinstruction that transferred execution to the second region, and/or byexamining a descriptor associated with the location of execution beforethe recognized execution transfer.

A first class of instructions may include instructions to transfercontrol between subprograms associated with arguments passed accordingto a calling convention, and a second class of instructions may includebranch instructions whose arguments, if any, are not passed according tothe calling convention. One of the execution contexts may be aregister-based calling convention, and the other execution context maybe a memory stack-based calling convention. The rearrangement mayreflect analogous execution contexts under the two data storageconventions, the rearranging process being determined, at least in part,by the instruction classification record. In some of the control-flowinstructions, the classification may be encoded in an immediate field ofinstructions, the immediate field having no effect on the execution ofthe instruction in which it is encoded, except to update the classrecord. In some of the control-flow instructions, the classification maybe statically determined by the opcode of the instructions. In some ofthe control-flow instructions, the classification may be dynamicallydetermined with reference to a state of processor registers and/orgeneral registers of the computer. In some of the control-flowinstructions, the classification may be dynamically determined based ona full/empty status of a register indicated by a top-of-stack pointer,the register holding a function result value. The rearranging may beperformed by an exception handler, the handler being selected by anexception vector based at least in part on the source data storageconvention, the destination data storage convention, and the instructionclassification record. Instructions of the instruction set may beclassified as members of a don't-care class, so that when an instructionof the don't-care class is executed, the record is left undisturbed toindicate the class of the classified instruction most recently executed.The destination instruction may be an entry point to an off-the-shelfbinary for an operating system coded in an instruction set non-native tothe computer.

The operating system may be an operating system for a computerarchitecture other than the architecture native to the computer. Thecomputer may additionally execute an operating system native to thecomputer, and each exception may be classified for handling by one ofthe two operating systems. A linkage return address for resumption ofthe thread may be modified to include information used to maintain theassociation. At least some of the modified registers may be overwrittenby a timestamp. The entry exception handler may alter at least half ofthe data registers of the portion of a process context maintained inassociation with the process by the operating system before deliveringthe process to the operating system, a validation stamp beingredundantly stored in at least one of the registers, and wherein atleast some of the modified registers are overwritten by a valueindicating the storage location in which at least the portion of thethread context is saved before the modifying. The operating system andthe interrupted thread may execute in different instruction setarchitectures of the computer. During servicing the entry exception, aportion of the context of the computer may be saved, and the context ofan interrupted thread may be altered before delivering the interruptedthread and its corresponding context to the operating system. When thethread scheduler and the thread execute in different execution modes ofthe computer, the steps to maintain the association between the threadand the context may be automatically invoked on a transition from thethread execution mode to the thread scheduler execution mode. The threadcontext may be saved in a storage location allocated from a pool ofstorage locations managed by a queuing discipline in which empty storagelocations in which a context is to be saved are allocated from the headof the queue, recently-emptied storage locations for reuse are enqueuedat the head of the queue, and full storage locations to be saved arequeued at the tail of the queue. A calling convention for the threadexecution mode may require the setting of a register to a value thatspecifies actions to be taken to convert operands from one form toanother to conform to the thread scheduler execution mode. Delivery ofan interrupt may be deferred by a time sufficient to allow the thread toreach a checkpoint, or execution of the thread may be rolled back to acheckpoint, the checkpoints being points in the execution of the threadwhere the amount of extended context, being the resources of the threadbeyond those whose resource association with the thread is maintained bythe thread scheduler, is reduced. The linkage return address may beselected to point to a memory page having a memory attribute that raisesthe chosen exception on at attempt to execute an instruction from thepage. The service routine may be an interrupt service routine of anoperating system for a computer architecture other than the architecturenative to the computer, the service routine may be invoked by anasynchronous interrupt, and the caller may be coded in the instructionset native to the architecture.

In general, in a twelfth aspect, the invention features a method and acomputer. A computer program executes in a logical address space of acomputer, with an address translation circuit translating addressreferences generated by the program from the program's logical addressspace to the computer's physical address space. Profile information isrecorded that records physical memory addresses referenced during anexecution interval of the program.

In general, in a thirteenth aspect, a program is executed on a computer,the program referring to memory by virtual address. Concurrently withthe execution of the program, profile information is recorded describingmemory references made by the program, the profile information recordingphysical addresses of the profiled memory references.

In general, in a fourteenth aspect, the invention features a computerwith an instruction pipeline, a memory access unit, an addresstranslation circuit, and profile circuitry. The instruction pipeline andmemory access unit are configured to execute instructions in a logicaladdress space of a memory of the computer. The address translationcircuit translates address references generated by the program from theprogram's logical address space to the computer's physical addressspace. The profile circuitry is cooperatively interconnected with theinstruction pipeline and is configured to detect, without compilerassistance for execution profiling, occurrence of profileable eventsoccurring in the instruction pipeline, and cooperatively interconnectedwith the memory access unit to record profile information describingphysical memory addresses referenced during an execution interval of theprogram.

Embodiments of the invention may include one or more of the followingfeatures. The recorded physical memory references may include addressesof binary instructions referenced by an instruction pointer, and atleast one of the recorded instruction references may record the event ofa sequential execution flow across a page boundary in the address space.The recorded execution flow across a page boundary may occur within asingle instruction. The recorded execution flow across a page boundarymay occur between two instructions that are sequentially adjacent in thelogical address space. At least one of the recorded instructionreferences may be a divergence of control flow consequent to an externalinterrupt. At least one of the recorded instruction references mayindicate the address of the last byte of an instruction executed by thecomputer during the profiled execution interval. The recorded profileinformation may record a processor mode that determines the meaning ofbinary instructions of the computer. The recorded profile informationmay record a data-dependent change to a full/empty mask for registers ofthe computer. The instruction pipeline may be configured to executeinstructions of two instruction sets, a native instruction set providingaccess to substantially all of the resources of the computer, and anon-native instruction set providing access to a subset of the resourcesof the computer. The instruction pipeline and profile circuitry may befurther configured to effect recording of profile information describingan interval of the execution of an operating system coded in thenon-native instruction set.

In general, in a fifteenth aspect, the invention features a method. Aprogram is executed on a computer. Profile information is recordedconcerning the execution of the program, the profile informationrecording of the address of the last byte of at least one instructionexecuted by the computer during a profiled interval of the execution.

In general, in a sixteenth aspect the invention features a method. Aprogram is executed on a computer, without the program having beencompiled for profiled execution, the program being coded in aninstruction set in which an interpretation of an instruction depends ona processor mode not expressed in the binary representation of theinstruction. Profile information is recorded describing an interval ofthe program's execution and processor mode during the profiled intervalof the program, the profile information being efficiently tailored toannotate the profiled binary code with sufficient processor modeinformation to resolve mode-dependency in the binary coding.

In general, in an seventeenth aspect the invention features a computerwith an instruction pipeline and profile circuitry. The instructionpipeline is configured to execute instructions of the computer. Theprofile circuitry is configured to detect and record, without compilerassistance for execution profiling, profile information describing asequence of events occurring in the instruction pipeline, the sequenceincluding every event occurring during a profiled execution intervalthat matches time-independent selection criteria of events to beprofiled, the recording continuing until a predetermined stop conditionis reached, and is configured to detect the occurrence of apredetermined condition to commence the profiled execution intervalafter a non-profiled interval of execution.

In general, in a eighteenth aspect, the invention features a method anda computer with circuitry configured for performance of the method.During a profiled interval of an execution of a program on a computer,profile information is recorded describing the execution, without theprogram having been compiled for profiled execution, the program beingcoded in an instruction set in which an interpretation of an instructiondepends on a processor mode not expressed in the binary representationof the instruction, the recorded profile information describing at leastall events occurring during the profiled execution interval of the twoclasses: (1) a divergence of execution from sequential execution; and(2) a processor mode change that is not inferable, from the opcode ofthe instruction that induces the processor mode change taken togetherwith a processor mode before the mode change instruction. The profileinformation further identifies each distinct physical page ofinstruction text executed during the execution interval.

Embodiments of the invention may include one or more of the followingfeatures. The profiled execution interval is commenced at the expirationof a timer, the recorded profile describing a sequence of eventsincluding every event that matches time-independent selection criteriaof events to be profiled, the recording continuing until a predeterminedstop condition is reached. A profile entry is recorded for lateranalysis noting the source and destination of a control flow event inwhich control flow of the program execution diverges from sequentialexecution. The recorded profile information is efficiently tailored toidentify all bytes of object code executed during the profiled executioninterval, without reference to the binary code of the program. A profileentry describing a single profileable event explicitly describes a pageoffset of the location of the event, and inherits a page number of thelocation of the event from the immediately preceding profile entry.Profile information records a sequence of events of the program, thesequence including every event during the profiled execution intervalthat matches time-independent criteria of profileable events to beprofiled. The recorded profile information indicates ranges ofinstruction binary text executed by the computer during a profiledinterval of the execution, the ranges of executed text being recorded aslow and high boundaries of the respective ranges. The recorded highboundaries record the last byte, or the first byte of the lastinstruction, of the range. The captured profile information comprisessubunits of two kinds, a first subunit kind describing an instructioninterpretation mode at an instruction boundary, and a second subunitkind describing a transition between processor modes. During anon-profiled interval of the program execution, no profile informationis recorded in response to the occurrence of profileable events matchingpredefined selection criteria for profileable events. The profilecircuitry is designed to record a timestamp describing a time of therecorded events. The profile circuitry is designed to record an eventcode describing the class of each profileable event recorded. A numberof bits used to record the event code is less than log₂ of the number ofdistinguished event classes.

In general, in a nineteenth aspect, the invention features a method.While executing a program on a computer, the occurrence of profileableevents occurring in the instruction pipeline is detected, and theinstruction pipeline is directed to record profile informationdescribing the profileable events essentially concurrently with theoccurrence of the profileable events, the detecting and recordingoccurring under control of hardware of the computer without softwareintervention.

In general, in a twentieth aspect, the invention features a computerthat includes an instruction pipeline and profile circuitry. Theinstruction pipeline includes an arithmetic unit and is configured toexecute instructions received from a memory of the computer and theprofile circuitry. The profile circuitry is common hardware control withthe instruction pipeline. The profile circuitry and instruction pipelineare cooperatively interconnected to detect the occurrence of profileableevents occurring in the instruction pipeline, the profile circuitryoperable without software intervention to effect recording of profileinformation describing the profileable events essentially concurrentlywith the occurrence of the profileable events.

In general, in a twenty-first aspect, the invention features first andsecond CPU's. The first CPU is configured to execute a program andgenerate profile data describing the execution of the program. Thesecond CPU is configured to analyze the generated profile data, whilethe execution and profile data generation continue on the first CPU, andto control the execution of the program on the first CPU based at leastin part on the analysis of the collected profile data.

In general, in a twenty-second aspect, the invention features a method.While executing a program on a computer, the computer using registers ofa general register file for storage of instruction results, theoccurrence of profileable events occurring in the instruction pipelineis detected. Profile information is recorded describing the profileableevents into the general register file as the profileable events occur,without first capturing the information into a main memory of thecomputer.

In general, in a twenty-third aspect, the invention features a computerthat includes a general register file of registers, an instructionpipeline and profile circuitry. The instruction pipeline includes anarithmetic unit and is configured to execute instructions fetched from amemory cache of the computer, and is in data communication with theregisters for the general register file for storage of instructionresults. The profile circuitry is operatively interconnected with theinstruction pipeline and is configured to detect the occurrence ofprofileable events occurring in the instruction pipeline, and to captureinformation describing the profileable events into the general registerfile as the profileable events occur, without first capturing theinformation into a main memory of the computer.

In general, in a twenty-fourth aspect, the invention features acomputer. The instruction pipeline is configured to execute instructionsof the computer. The profile circuitry is implemented in the computerhardware, and is configured to detect, without compiler assistance forexecution profiling, the occurrence of profileable events occurring inthe instruction pipeline, and to direct recording of profile informationdescribing the profileable events occurring during an execution intervalof the program. Profile control bits implemented in the computerhardware have values that control a resolution of the operation of theprofile circuitry. A binary translator is configured to translateprograms coded in a first instruction set architecture into instructionsof a second instruction set architecture. A profile analyzer isconfigured to analyze the recorded profile information, and to set theprofile control bits to values to improve the operation of the binarytranslator.

Embodiments of the invention may include one or more of the followingfeatures. At least a portion of the recording is performed byinstructions speculatively introduced into the instruction pipeline. Theprofile circuitry is interconnected with the instruction pipeline todirect the recording by injection of an instruction into the pipeline,the instruction controlling the pipeline to cause the profileable eventto be materialized in an architecturally-visible storage register of thecomputer. An instruction of the computer, having a primary effect on theexecution the computer not related to profiling, has an immediate fieldfor an event code encoding the nature of a profiled event and to berecorded in the profile information, the immediate field having noeffect on computer execution other than to determine the event code ofthe profiled event. Instances of the instruction have an event code thatleaves intact an event code previously determined by other eventmonitoring circuitry of the computer. The profiled information includesdescriptions of events whose event codes were classified by instructionexecution hardware, without any explicit immediate value being recordedin software. The instruction pipeline and profile circuitry areoperatively interconnected to effect injection of multiple instructionsinto the instruction pipeline by the profile circuitry on the occurrenceof a single profileable event. The instruction pipeline and profilecircuitry are operatively interconnected to effect speculative injectionof the instruction into the instruction pipeline by the profilecircuitry. A register pointer of the computer indicates a generalregister into which to record the profile information, and anincrementer is configured to increment the value of the register pointerto indicate a next general register into which to record next profileinformation, the incrementing occurring without software intervention. Alimit detector is operatively interconnected with the register pointerto detect when a range of registers available for collecting profileinformation is exhausted, and a store unit is operatively interconnectedwith the limit detector of effect storing the profile information fromthe general registers to the main memory of the computer when exhaustionis detected. The profile circuitry comprises a plurality of storageregisters arranged in a plurality of pipeline stages, informationrecorded in a given pipeline stage being subject to modification as acorresponding machine instruction progresses through the instructionpipeline. When an instruction fetch of an instruction causes a miss in atranslation look aside buffer (TLB), the fetch of the instructiontriggering a profileable event, the TLB miss is serviced, and thecorrected state of the TLB is reflected in the profile informationrecorded for the profileable instruction. The profile control bitsinclude a timer interval value specifying a frequency at which theprofile circuitry is to monitor the instruction pipeline for profileableevents. The profile circuitry comprises a plurality of storage registersarranged in a plurality of pipeline stages, information recorded in agiven pipeline stage is subject to modification as a correspondingmachine instruction progresses through the instruction pipeline.

In general, in a twenty-fifth aspect, the invention features a computerwith instruction pipeline circuitry designed to effect interpretation ofcomputer instructions under two instruction set architecturesalternately. Pipeline control circuitry is cooperatively designed withthe instruction pipeline circuitry to initiate, without softwareintervention, when about to execute a program region coded in alower-performance one of the instruction set architectures, a querywhether a program region coded in a higher-performance one of theinstruction set architectures exists, the higher-performance regionbeing logically equivalent to the lower-performance program region.Circuitry and/or software is designed to transfer execution control tothe higher-performance region, without a transfer-of-control instructionto the higher-performance region being coded in the lower-performanceinstruction set.

In general, in a twenty-sixth aspect, the invention features a methodand a computer for performance of the method. At least a selectedportion of a computer program is translated from a first binaryrepresentation to a second binary representation. During execution ofthe first binary representation of the program on a computer, it isrecognized that execution has entered the selected portion, therecognizing being initiated by basic instruction execution of thecomputer, with neither a query nor a transfer of control to the secondbinary representation being coded into the first binary representation.In response to the recognition, control is transferred to thetranslation in the second representation.

In general, in a twenty-seventh aspect, the invention features a methodand a computer for performance of the method. As part of executing aninstruction on a computer, it is recognized that an alternate coding ofthe instruction exists, the recognizing being initiated withoutexecuting a transfer of control to the alternate coding or queryinstruction to trigger the recognizing. When an alternate coding exists,the execution of the instruction is aborted, and control is transferredto the alternate coding.

In general, in a twenty-eighth aspect, the invention features a methodand a computer for performance of the method. During execution of aprogram on instruction pipeline circuitry of a computer, a determinationis initiated of whether to transfer control from a first instructionstream in execution by the instruction pipeline circuitry to a secondinstruction stream, without a query or transfer of control to the secondinstruction stream being coded into the first instruction stream.Execution of the first instruction stream is established after executionof the second instruction stream, execution of the first instructionstream being reestablished at a point downstream from the point at whichcontrol was seized, in a context logically equivalent to that whichwould have prevailed had the code of the first instruction stream beenallowed to proceed.

In general, in a twenty-ninth aspect, the invention features a methodand a computer for performance of the method. Execution of a computerprogram is initiated, using a first binary image of the program. Duringthe execution of the first image, control is transferred to a secondimage coding the same program in a different instruction set.

In general, in a thirtieth aspect, the invention features a method and acomputer for performance of the method. As part of executing aninstruction on a computer, a heuristic, approximately-correctrecognition that an alternate coding of the instruction exists isevaluated, the process for recognizing being statistically triggered. Ifthe alternate coding exists, execution of the instruction is aborted,and control is transferred to the alternate coding.

In general, in a thirty-first aspect, the invention features a methodand a computer for performance of the method. A microprocessor chip hasinstruction pipeline circuitry, lookup circuitry, a mask, and pipelinecontrol circuitry. The lookup circuitry is designed to fetch an entryfrom a lookup structure as part of the basic instruction processingcycle of the microprocessor, each entry of the lookup structure beingassociated with a corresponding address range of a memory of thecomputer. The mask has a value set at least in part by a timer. Thepipeline control circuitry is designed to control processing ofinstructions by the instruction pipeline circuitry as part of the basicinstruction processing cycle of the microprocessor, depending, at leastin part, on the value of the entry corresponding to the address range inwhich lies an instruction processed by the instruction pipelinecircuitry, and the current value of the mask.

In general, in a thirty-second aspect, the invention features a methodand a microprocessor chip for performance of the method. Themicroprocessor chip has instruction pipeline circuitry; instructionclassification circuitry responsive to execution of instructionsexecuted by the instruction pipeline circuitry to classify the executedinstructions into a small number of classes and record a classificationcode value; lookup circuitry designed to fetch an entry from a lookupstructure as part of the basic instruction processing cycle of themicroprocessor, each entry of the lookup structure being associated witha corresponding address range of a memory of the computer; and pipelinecontrol circuitry designed to control processing of instructions by theinstruction pipeline circuitry as part of the basic instructionprocessing cycle of the microprocessor, depending, at least in part, onthe value of the entry corresponding to the address range in which theinstruction address lies, and the recorded classification code.

In general, in a thirty-third aspect, the invention features a methodand a microprocessor chip for performance of the method. Themicroprocessor chip includes instruction pipeline circuitry; an on-chiptable, each entry of the on-chip table corresponding to a respectiveclass of event occurring the in the computer, and designed to hold anapproximate evaluation of a portion of the computer machine state forcontrol of the circuitry; and pipeline control circuitry cooperativelydesigned with the instruction pipeline circuitry to control processingof instructions by the instruction pipeline circuitry as part of thebasic instruction processing cycle of the microprocessor, based onconsultation of the on-chip table.

In general, in a thirty-fourth aspect, the invention features a methodand a microprocessor chip for performance of the method. Themicroprocessor chip includes instruction pipeline circuitry; an on-chiptable, each entry of the on-chip table corresponding to a class of eventoccurring the in the computer and designed to control consultation of anoff-chip table in a memory of the computer when an event of the classoccurs; pipeline control circuitry cooperatively designed with theinstruction pipeline circuitry to consult the on-chip table as part ofthe basic instruction processing cycle of the microprocessor, as theclassified events occur; and control circuitry and/or software designedto cooperate with the instruction pipeline circuitry and pipelinecontrol circuitry to affect a manipulation of data or transfer ofcontrol defined for the event in the instruction pipeline circuitrybased on consultation of the off-chip table after a favorable value isobtained from the on-chip table.

Embodiments of the invention may include one or more of the followingfeatures. The transfer of execution control to the higher-performanceregion may be effected by an architecturally-visible alteration of aprogram counter. The region about to be executed may be entered by atransfer of control instruction. The first image may be coded in aninstruction set non-native to the computer, for hardware emulation inthe computer. Instructions of the second binary representation may becoded in a different instruction set architecture than instructions ofthe first binary representation. The second image may have beengenerated from the first image by a binary translator. The binarytranslator may have optimized the second image for increased executionspeed, while accepting some risk of execution differing from theexecution of the non-native program on its native instruction setarchitecture. A decision on whether to transfer control from the firstimage to the second may be based on control variables of the computer.The classes of events may be memory references to correspondingrespective address ranges of a memory of the computer. The addressranges may correspond to entries in an interrupt vector table. Therecognition may be initiated by consulting a content-addressable memoryaddressed by a program counter address of the instruction to beexecuted. The content-addressable memory may be a translation lookasidebuffer. The off-chip table may be organized as a side table to anaddress translation page table. The on-chip table may contain acondensed approximation of the off-chip table, loaded from the off-chiptable. The lookup structure may be a bit vector. Bits of the entrycorresponding to the address range in which the instruction address liesmay be AND'ed with corresponding bits of a mask associated with theinstruction pipeline circuitry. Error in the approximation of theon-chip table may be induced by a slight time lag relative to theportion of the computer's machine state whose evaluation is storedtherein. The pipeline control circuitry may be designed to controlprocessing of instructions by the instruction pipeline circuitry byevaluating the value of the entry corresponding to the address range inwhich the instruction address lies and the recorded classification code,and triggering a software evaluation of a content of the memoryaddressed by the microprocessor chip. The control of instructionprocessing may include branch destination processing.

In general, in a thirty-fifth aspect, the invention features a methodand a microprocessor chip for performance of the method. Instructionsare executed on a computer, instruction pipeline circuitry of thecomputer having first and second modes for processing at least some ofthe instructions. Execution of two-mode instructions is attempted in thefirst mode for successive two-mode instructions while the firstexecution mode is successful. When an unsuccessful execution of atwo-mode instruction under the first mode is detected, followingtwo-mode instructions are executed in the second mode.

In general, in a thirty-sixth aspect, the invention features a methodand a microprocessor chip for performance of the method. Computerinstructions are executed in instruction pipeline circuitry having firstand second modes for processing at least some instructions. Onexpiration of a timer, the instruction pipeline circuitry switches fromthe first mode to the second, the mode switch persisting forinstructions subsequently executed on behalf of a program that was inexecution immediately before the timer expiry.

In general, in a thirty-seventh aspect, the invention features a methodand a microprocessor chip for performance of the method. Events of acomputer are assigned into event classes. As part of the basic executioncycle of a computer instruction pipeline, without software intervention,a record of responses to events of the class is maintained. As eachclassified event comes up for execution in the instruction pipelinecircuitry, the record is queried to determine the response to theprevious attempt of an event of the same class. The response isattempted if and only if the record indicates that the previous attemptsucceeded.

Embodiments of the invention may include one or more of the followingfeatures. The first and second modes may be alternative cache policies,or alternative modes for performing floating-point arithmetic.Unsuccessful execution may includes correct completion of an instructionat a high cost. The cost metric may be execution time. The cost of aninstruction in the first mode may be only ascertainable after completionof the instruction. The instruction pipeline circuitry may be switchedback from the second mode to the first, the switch persisting until thenext timer expiry. All of the records may be periodically set toindicate that previous attempts of the corresponding events succeeded.

In general, in a thirty-eighth aspect, the invention features a methodand a microprocessor chip for performance of the method. As part of thebasic instruction cycle of executing an instruction of a non-supervisormode program executing on a computer, a table is consulted, the tablebeing addressed by the address of instructions executed, for attributesof the instructions. An architecturally-visible data manipulationbehavior or control transfer behavior of the instruction is controlledbased on the contents of a table entry associated with the instruction.

Embodiments of the invention may include one or more of the followingfeatures. The different instruction may be coded in an instruction setarchitecture (ISA) different than the ISA of the executed instruction.The control of architecturally-visible data manipulation behavior mayinclude changing an instruction set architecture under whichinstructions are interpreted by the computer. Each entry of the tablemay correspond to a page managed by a virtual memory manager, circuitryfor locating a table entry being integrated with virtual memory addresstranslation circuitry of the computer. An interrupt may be triggered onexecution of an instruction of a process, synchronously based at leastin part on a memory state of the computer and the address of theinstruction, the architectural definition of the instruction not callingfor an interrupt. Interrupt handler software may be provided to servicethe interrupt and to return control to an instruction flow of theprocess other than the instruction flow triggering the interrupt, thereturned-to instruction flow for carrying on non-error handling normalprocessing of the process.

In general, in a thirty-ninth aspect, the invention features a methodand a microprocessor chip for performance of the method. Amicroprocessor chip has instruction pipeline circuitry, addresstranslation circuitry; and a lookup structure. The lookup structure hasan entry associated with each corresponding address range translated bythe address translation circuitry, the entry describing a likelihood ofthe existence of an alternate coding of instructions located in therespective corresponding address range.

Embodiments of the invention may include one or more of the followingfeatures. The entry may be an entry of a translation look-aside buffer.The alternate coding may be coded in an instruction set architecture(ISA) different than the ISA of the instruction located in the addressrange.

In general, in a fortieth aspect, the invention features a method and amicroprocessor chip for performance of the method. A microprocessor chiphas instruction pipeline circuitry and interrupt circuitry. Theinterrupt circuitry is cooperatively designed with the instructionpipeline circuitry to trigger an interrupt on execution of aninstruction of a process, synchronously based at least in part on amemory state of the computer and the address of the instruction, thearchitectural definition of the instruction not calling for aninterrupt.

Embodiments of the invention may include one or more of the followingfeatures. Interrupt handler software may be designed to service theinterrupt and to return control to an instruction flow of the processother than the instruction flow triggering the interrupt, thereturned-to instruction flow for carrying on non-error handling normalprocessing of the process. The interrupt handler software may beprogrammed to change an instruction set architecture under whichinstructions are interpreted by the computer. The instruction textbeginning at the returned-to instruction may be logically equivalent tothe instruction text beginning at the interrupted instruction.

In general, in a forty-first aspect, the invention features a method anda microprocessor chip for performance of the method. As part ofexecuting a stream of instructions, a series of memory loads is issuedfrom a computer CPU to a bus, some directed to well-behaved memory andsome directed to non-well-behaved devices in I/O space. A storage of thecomputer records addresses of instructions of the stream that issuedmemory loads to the non-well-behaved memory, the storage form of therecording allowing determination of whether the memory load was towell-behaved memory or not-well-behaved memory without resolution of anymemory address stored in the recording.

In general, in a forty-second aspect, the invention features a methodand a computer for performance of the method. A successful memoryreference is issued from a computer CPU to a bus. A storage of thecomputer records whether a device accessed over the bus by the memoryreference is well-behaved memory or not-well-behaved memory.Alternatively, the memory may store a record of a memory readinstruction that references a device other than well-behaved memory.

Embodiments of the invention may include one or more of the followingfeatures. The recording may be a portion of a profile primarilyrecording program control flow. The recording may be read by a binarytranslation program, wherein the binary translation program translatesthe memory load using more conservative assumptions when the recordingindicates that the memory load is directed to non-well-behaved memory.References to I/O space may be recorded as being references tonon-well-behaved memory. The recording may be slightly in error, theerror being induced by a conservative estimate in determining when thememory reference accesses well-behaved memory. The form of the recordingmay allow determination of whether the memory reference was towell-behaved memory or not-well-behaved memory without resolution of anymemory address stored in the recording. The form of the recording mayindicates an address of an instruction that issued the memory reference.The memory reference may be a load. The profile monitoring circuitry maybe interwoven with the computer CPU. A TLB (translation lookasidebuffer) may be designed to hold a determination of whether memory mappedby entries of the TLB is well-behaved or non-well-behaved memory. Theprofile monitoring circuitry may generate the record into a generalpurpose register of the computer. The profile monitoring circuitry maybe designed to induce a pipeline flush of the computer CPU.

In general, in a forty-third aspect, the invention features a method andcomputer circuitry for performance of the method. DMA (direct memoryaccess) memory write transactions of a computer are monitored, and anindication of a memory location written by a DMA memory writetransaction is recorded, by circuitry operating without being informedof the memory write transaction by the CPU beforehand. The indication isread by the CPU.

In general, in a forty-fourth aspect, the invention features a methodand computer for performance of the method. A first process of acomputer generates a second representation in a computer memory ofinformation stored in the memory in a first representation. Overwritingof the first representation by a DMA memory write transaction initiatedby a second process is detected by the first process, without the secondprocess informing the first process of the DMA memory write transaction,the detecting guaranteed to occur no later than the next access of thesecond representation following the DMA memory write transaction.

In general, in a forty-fifth aspect, the invention features a method andcomputer for performance of the method. A computer's main memory isdivided into pages for management by a virtual memory manager. Themanager manages the pages using a table stored in the memory. Circuitryrecords indications of modification to pages of the main memory into aplurality of registers outside the address space of the main memory. Thevirtual memory management tables do not provide backing store for themodification indications stored in the registers.

In general, in a forty-sixth aspect, the invention features a method andcomputer circuitry for performance of the method. Modifications to thecontents of a main memory of a computer are monitored, and on detectionof a modification, an approximation of the address of the modificationis written into an address tag of one of a plurality of registers, and afine indication of the address of the modification is written into amemory cell of a plurality of cells of the register. The fine indicationof the address of the modification is provided to a CPU of the computerthrough a read request from the CPU.

Embodiments of the invention may include one or more of the followingfeatures. The recorded indication may record only the memory location,and not the datum written to the location. Based at least in part by thevalue read by the CPU, a cached datum may be erased. Two DMA memorywrites near each other in address and time may generate only a singlerecord of a write. The recorded indication of a location in the mainmemory may indicate a physical address in the memory. A value of eachbit of a bit vector may indicate whether a corresponding region in themain memory has been recently modified. Matching circuitry may beprovided to match an address of a memory modification to an address of apreviously-stored indication of a previous nearby memory modification.The recorded indication of a location in the main memory may beinitially recorded in an architecturally-visible location outside themain memory and outside a general register file of the computer. Therecorded indication of a location in the main memory may be recorded, atleast in part, based on a subdivision of the main memory into regionseach consisting of a naturally-aligned block of pages of the memory. TheDMA monitoring circuitry being designed to monitor transactions on I/Ogateway circuitry between the CPU and the DMA devices. The DMAmonitoring circuitry may dismiss a content of the DMA monitoringcircuitry as a side-effect of being read. The address of themodification stored in the address tag may be a physical memory address.The vector of memory cells may include a bit vector, a value of each bitof the bit vector designed to indicate whether a corresponding region inthe main memory has been recently modified. The address tag may includea content-addressable memory. A one of the plurality of registers may beassociated with an address range by writing an address into the addresstag of the one register. Later, the one register may be associated witha different address range by writing a different address into theaddress tag of the one register. A value of each bit of a bit vector mayindicate whether a corresponding region in the main memory has beenrecently modified.

In general, in a forty-seventh aspect, the invention features a methodand computer for performance of the method. As a program is executed ina computer, writes to a protected region of a main memory of thecomputer are detected, the reporting being performed by monitoringcircuitry of the computer. On receiving the report of the detection, adata structure of content corresponding to the content of the protectedregion to which the write was detected is deleted from the memory.

In general, in a forty-eighth aspect, the invention features a methodand computer for performance of the method. Memory read references aregenerated in a CPU of a computer, the memory references referring tological addresses. Circuitry and/or software evaluates whether mainmemory pages of the references are in a protected state. Pages that areunprotected are put into a protected state.

In general, in a forty-ninth aspect, the invention features a method andcomputer for performance of the method. Memory references are generatedby a CPU of a computer, the memory references referring to logicaladdresses. The translation of logical addresses into a physicaladdresses evaluates whether the page of the reference is protectedagainst the access. Pages that are protected have their protectionmodified, without modifying the contents of the page.

Embodiments of the invention may include one or more of the followingfeatures. The monitoring and detection circuitry may be responsive tomemory writes generated by store operations initiated by instructionsexecuted by pipeline circuitry of the computer. The evaluation circuitrymay be incorporated into address translation circuitry designed totranslate logical addresses, generated as part of memory read accessesby a CPU of the computer, into physical addresses. The protection ofmemory regions may be recorded in a table of entries, each entrycorresponding to a page of the main memory. The table entries may beorganized in correspondence to physical pages of the main memory. Thetable entries may constitute a table in main memory distinct from a pagetable used by a virtual memory manager of the computer. The table ofentries may be a translation lookaside buffer. A profiling or monitoringfunction of the computer may be enabled or disabled for regions of thememory of the computer, based on whether the respective regions areprotected or unprotected. An arithmetic result or branch destination ofan instruction may be controlled based on whether a region containingthe instruction is protection or unprotected. The data structure may beformed by translating a computer program stored in the protected regionin a first instruction set architecture into a second instruction setarchitecture. On receiving the report of the detection, an interrupt maybe raised to invoke software, the invoked software affecting thecontents of the memory without reference to the contents of theprotected region. The memory read reference may be an instruction fetch.

In general, in a fiftieth aspect, the invention features a method andcomputer for performance of the method. Memory references generated aspart of executing a stream of instructions on a computer are evaluatedto determined whether an individual memory reference of an instructionreferences a device having a valid memory address but that cannot beguaranteed to be well-behaved.

In general, in a fifty-first aspect, the invention features a method andcomputer for performance of the method. While translating at least asegment of a binary representation of a program from a first instructionset architecture to a second representation in a second instruction setarchitecture, individual memory loads that are believed to be directedto well-behaved memory are distinguished from memory loads that arebelieved to be directed to non-well-behaved memory device(s). Whileexecuting the second representation, a load is identified that wasbelieved at translation time to be directed to well-behaved memory butthat at execution is found to be directed to non-well-behaved memory.The identified memory load is aborted. Based at least in part on theidentifying, at least a portion of the translated segment of the programis re-executed in the first instruction set.

In general, in a fifty-second aspect, the invention features a methodand computer for performance of the method. A binary translatortranslates at least segment of a program from a first representation ina first instruction set architecture to a second representation in asecond instruction set architecture, a sequence of side-effects in thesecond representation differing from a sequence of side-effects in thetranslated segment of the first representation. Instruction executioncircuitry and/or software identifies cases during execution of thesecond representation in which the difference in sequence ofside-effects may have a material effect on the execution of the program.A program state, equivalent to a state that would have occurred in theexecution of the first representation, is established. Execution resumesfrom the established state in an execution mode that reflects theside-effect sequence of the first representation.

Embodiments of the invention may include one or more of the followingfeatures. If the reference cannot be guaranteed to be well-behaved, theinstruction may be re-executed in an alternative execution mode, orprogram state may be restored to a prior state. The secondrepresentation may be annotated with an indication of the distinctionbetween individual memory loads that are believed to be directed towell-behaved memory from memory loads that are believed to be directedto non-well-behaved memory. The device having a valid memory address mayhave an address in an I/O space of the computer. Code in a preamble of aprogram unit embracing the memory-reference instruction may establish astate of the instruction execution circuitry, the instruction executioncircuitry designed to raise an exception based on an evaluation of boththe state and the evaluation of the reference to the device. Anannotation embedded in the instruction may be evaluated to determinewhether the reference to the non-well-behaved device is to raise anexception. An evaluation of whether the instruction of the individualside-effect is to raise an exception may occur in circuitry embedded inan address translation circuitry of the computer. An exception may beraised, based on an evaluation of both a segment descriptor and theevaluation of the side-effect. An annotation encoded in a segmentdescriptor may be evaluated to determine whether the reference to thenon-well-behaved device is to raise an exception. The segment descriptormay be formed by copying another segment descriptor, and altering theannotation. The formed segment descriptor may copy a variable indicatingan assumed sensitivity of the translation to alteration of the sequenceof side-effects. The difference of ordering of side-effects may includea reordering of two side-effects relative to each other, an eliminationof a side-effect by the translating, or combining two side-effects inthe binary translator. The restoring step may be initiated when anexception occurs in the object program. Execution may resume from therestored state, the resumed execution executing a precise side-effectemulation of the reference implementation. A descriptor generated duringthe translation may be used to restore state to the pre-exceptionreference state.

In general, in a fifty-third aspect, the invention features a method andcomputer for performance of the method. A first interpreter executes aprogram coded in an instruction set, the first interpreter being lessthan fully correct. A second, fully-correct interpreter, primarily inhardware, executes instructions of the instruction set. A monitordetects any deviation from fully-correct interpretation by the firstinterpreter, before any side-effect of the incorrect interpretation isirreversibly committed. When the monitor detects the deviation,execution is rolled back by at least a full instruction to a safe pointin the program, and execution is reinitiated in the second interpreter.

In general, in a fifty-forth aspect, the invention features a method andcomputer for performance of the method. A binary translator translates asource program into an object program, the translated object programhaving a different execution behavior than the source program. Aninterrupt handler responds to an interrupt occurring during execution ofthe object program by establishing a state of the program correspondingto a state that would have occurred during an execution of the sourceprogram, and from which execution can continue, and initiates executionof the source program from the established state.

Embodiments of the invention may include one or more of the followingfeatures. The first interpreter may include a software emulator, and/ora software binary translator. The second interpreter may interpretinstructions in an instruction set not native to the computer. Thesoftware binary translator may operate concurrently with execution ofthe program to translate a segment less than the whole of the program.Continuing execution may include rolling back execution of the firstinterpreter by at least two full instructions. Continuing execution mayinclude rolling back execution of the first interpreter from a state inwhich a number of distinct suboperations of several instructions havebeen intermixed by the first interpreter. Continuing execution mayinclude rolling back execution to a checkpoint, or allowing execution toprogress forward to a checkpoint in the first interpreter. The detecteddeviation from fully-correct interpretation may includes detection ofthe invalidity of a program transformation introduced by the binarytranslator, or detection of a synchronous execution exception.

Embodiments of the invention may offer one or more of the followingadvantages.

A program produced for a computer of an old architecture can be executedon a computer of a new architecture. The old binary can be executedwithout any modification. Old binaries can be mixed with new—forinstance, a program coded for an old architecture can call libraryroutines coded in the new instruction set, or vice-versa. Old librariesand new libraries may be freely mixed. New and old binaries may sharethe same address space, which improves the ability of new and oldbinaries to share common data. Alternatively, an old binary can be runin a protected separate address space on a new computer, without sharingany data with any new binary. A caller need not be aware of the ISA inwhich the callee is coded, avoiding the burden of explicitly saving andrestoring context. The invention reduces software complexity: softwareneed not make explicit provision for all possible entries and exits fromall possible modes and mixtures of binaries. The pipelines forprocessing old instructions and new instructions can share pieces of theimplementation, reducing the cost of supporting two instruction sets. Anew computer can fully model an older computer, with no reliance on anysoftware convention that may be imposed by any particular softwareproduct, allowing the new computer to run any program for the oldcomputer, including varying off-the-shelf operating systems. Becausetranslated target code is tracked in association with the physical pagesof the source code, even if the physical pages are mapped at differentpoints in the virtual address spaces, a single translation will bereused for all processes. This is particularly advantageous in the caseof shared libraries.

The profile data may be used in a “hot spot” detector, that identifiesportions of the program as frequently executed. Thosefrequently-executed portions can then be altered, either by a programmeror by software, to run more quickly. The profile data may be used by abinary translator to resolve ambiguities in the binary coding ofinstructions. The information generated by the profiler is completeenough that the hot spot detector can be driven off the profile, with noneed to refer to the instruction text itself. This reduces cachepollution. Ambiguities in the X86 instruction text (the meaning of agiven set of instructions that cannot be inferred from the instructiontext, for instance the operand size information from the segmentdescriptors) are resolved by reference to the profile information. Theinformation collected by the profiler compactly represents theinformation needed by the hot spot detector and the binary translator,with relatively little overhead, thereby reducing cache pollution. Theprofiler is integrated into the hardware implementation of the computer,allowing it to run fast, with little delay on a program—the overhead ofprofiling is only a few percent of execution speed.

Control may be transferred from an unoptimized instruction stream to anoptimized instruction stream, without any change to the unoptimizedinstruction stream. In these cases, the unoptimized instruction streamremains available as a reference for correct execution. The instructionstream may be annotated with information to control a variety ofexecution conditions.

A profile may be used to determine which program transformationoptimizations are safe and correct, and which present a risk of error.Rather than foregoing all opportunities unsafe optimizations orspeed-ups, the optimization or speed-up may be attempted, and monitoredfor actual success or failure. The slower, unoptimized mode of executioncan be invoked if the optimization in fact turns out to be unsafe.

The above advantages and features are of representative embodimentsonly, and are presented only to assist in understanding the invention.Additional features and advantages of the invention will become apparentin the following description, from the drawings, and from the claims.

DESCRIPTION OF THE DRAWING

FIGS. 1 a, 1 b, 1 c, 1 d and 3 a are block diagrams of a computersystem.

FIG. 1 e is a diagram of a PSW (program status word) of a system asshown in FIGS. 1 a-1 d.

FIG. 2 a is a table relating the meaning of several bits of the PSW ofFIG. 1 e.

FIGS. 2 b and 2 c are tables relating the actions of exception handlers.

FIGS. 3 b, 3 c, 3 d, 3 e, 3 f, 3 l, 3 m, 3 n and 3 o are block diagramsshowing program flow through memory.

FIGS. 3 g, 3 h, 3 i, 3 j, 6 c, 7 d, 8 b, and 8 c are flow diagrams.

FIGS. 3 k, 4 c, 4 d, and 7 j show data declarations or data structures.

FIGS. 4 a, 4 e and 4 f are block diagrams showing program flow throughmemory, and profile information describing that program flow.

FIG. 4 b is a table of profiling event codes and their meanings.

FIGS. 4 g, 4 h, 4 i, 7 c, 7 i and 8 a show processor registers of thecomputer.

FIG. 5 a shows a finite state machine for control of a profiler.

FIGS. 5 b, 6 b, 7 a, 7 b, 7 e, 7 f, 7 g, and 7 h are circuit blockdiagrams.

FIG. 6 a is a block diagram of PIPM (Physical IP map) and an entrythereof.

DESCRIPTION

The description is organized as follows.

-   I. Overview of the Tapestry system, and features of general use in    several aspects of the invention    -   A. System overview    -   B. The Tapestry instruction pipeline    -   C. Address translation as a control point for system features    -   D. Overview of binary translation, TAXi and the converter safety        net    -   E. System-wide controls    -   F. The XP bit and the unprotected exception-   II. Indicating the instruction set architecture (ISA) for program    text-   III. Saving Tapestry processor context in association with an X86    thread    -   A. Overview    -   B. Subprogram Prologs    -   C. X86-to-Tapestry transition handler    -   D. Tapestry-to-X86 transition handler    -   E. Handling ISA crossings on interrupts or exceptions in the        Tapestry operating system    -   F. Resuming Tapestry execution from the X86 operating system    -   G. An example    -   H. Alternative embodiments-   IV. An alternative method for managing transitions from one ISA to    the other    -   A. Indicating the calling convention (CC) for program text    -   B. Recording Transfer of Control Semantics and Reconciling        Calling Conventions-   V. Profiling to determine hot spots for translation    -   A. Overview of profiling    -   B. Profileable events and event codes    -   C. Storage form for profiled events    -   D. Profile information collected for a specific example event—a        page straddle    -   E. Control registers controlling the profiler    -   F. The profiler state machine and operation of the profiler    -   G. Determining the five-bit event code from a four-bit stored        form    -   H. Interaction of the profiler, exceptions, and the XP        protected/unprotected page property    -   I. Alternative embodiments-   VI. Probing to find a translation    -   A. Overview of probing    -   B. Overview of statistical probing    -   C. Hardware and software structures for statistical probing    -   D. Operation of statistical probing    -   E. Additional features of probing    -   F. Completing execution of TAXi code and returning to the X86        code    -   G. The interaction of probing and profiling    -   H. Alternative uses of adaptive opportunistic statistical        techniques-   VII. Validating and invalidating translated instructions    -   A. A simplified DMU model    -   B. Overview of a design that uses less memory    -   C. Sector Monitoring Registers    -   D. Interface and Status Register    -   E. Operation    -   F. Circuitry    -   G. DMU_Status register    -   H. DMU_Command register-   VIII. Managing out-of-order effects    -   A. Ensuring in-order handling of events reordered by optimized        translation    -   B. Profiling references to non-well-behaved memory    -   C. Reconstructing canonical machine state to arrive at a precise        boundary    -   D. Safety net execution-   IX. Interrupt priority

I. Overview of the Tapestry System, and Features of General use inSeveral Aspects of the Invention

A. System Overview

Referring to FIGS. 1 a, 1 b and 1 c, the invention is embodied in theTapestry product of Chromatic Research, Inc. of Sunnyvale, Calif.Tapestry is fast RISC processor 100, with hardware and software featuresthat provide a correct implementation of an Intel X86-family processor.(“X86” refers to the family including the 8086, 80186, . . . 80486,Pentium, and Pentium Pro. The family is described in Intel ArchitectureSoftware Developer's Manual, vol. 1-3, Intel Corp. (1997)) Tapestryfully implements the X86 architecture, in particular, a full Pentiumwith MMX extensions, including memory management, with no reliance onany software convention imposed, for instance, by a Microsoft or IBMoperating system. A Tapestry system will typically be populated by twoto four processors (only one of which is shown in FIGS. 1 a, 1 b and 1c), interconnected as symmetric shared memory multiprocessors.

Tapestry processor 100 fetches (stage 110) instructions from instructioncache (I-cache) 112, or from memory 118, from a location specified by IP(instruction pointer, generally known as the PC or program counter inother machines) 114, with virtual-to-physical address translationprovided by I-TLB (instruction translation look-aside buffer) 116. Theinstructions fetched from I-cache 112 are executed by a RISC executionpipeline 120. In addition to the services provided by a conventionalI-TLB, I-TLB 116 stores several bits 182, 186 that choose an instructionenvironment in which to interpret the fetched instruction bytes. One bit182 selects an instruction set architecture (ISA) for the instructionson a memory page. Thus, the Tapestry hardware can readily execute eithernative instructions or the instructions of the Intel X86 ISA. Thisfeature is discussed in more detail in section II, infra.

The execution of a program encoded in the X86 ISA is typically slowerthan execution of the same program that has been compiled into thenative Tapestry ISA. Profiler 400 records details of the execution flowof the X86 program. Profiling is discussed in greater detail in sectionV, infra. Hot spot detector 122 analyzes the profile to find “hotspots,” portions of the program that are frequently executed. When a hotspot is detected, a binary translator 124 translates the X86instructions of the hot spot into optimized native Tapestry code, called“TAXi code.” During emulation of the X86 program, prober 600 monitorsthe program flow for execution of X86 instructions that have beentranslated into native code. When prober 600 detects that translatednative Tapestry code exists corresponding to the X86 code about to beexecuted, and some additional correctness predicates are satisfied,prober 600 redirects the IP to fetch instructions from the translatednative code instead of from the X86 code. Probing is discussed ingreater detail in section VI, infra. The correspondence between X86 codeand translated native Tapestry code is maintained in PIPM (PhysicalInstruction Pointer Map) 602.

Because the X86 program text may be modified while under execution, thesystem monitors itself to detect operations that may invalidate aprevious translation of X86 program text. Such invalidating operationsinclude self-modifying code, and direct memory access (DMA) transfers.When such an operation is detected, the system invalidates any nativeTapestry translation that may exist corresponding to thepotentially-modified X86 text. Similarly, any other captured or cacheddata associated with the modified X86 data is invalidated, for instanceprofile data. These validity-management mechanisms are discussed ingreater detail in sections I.F, VII and VIII, infra.

The system does not translate instructions stored in non-DRAM memory,for instance ROM BIOS for I/O devices, memory-mapped control registers,etc.

Storage for translated native Tapestry code can also be released andreclaimed under a replacement policy, for instance least-recently-used(LRU) or first-in-first-out (FIFO).

A portion of the X86 program may be translated into native Tapestry codemultiple times during a single execution of the program. Typically, thetranslation is performed on one processor of the Tapestry multiprocessorwhile the execution is in progress on another.

For several years, Intel and others have implemented the X86 instructionset using a RISC execution core, though the RISC instruction set has notbeen exposed for use by programs. The Tapestry computer takes three newapproaches. First, the Tapestry machine exposes both the native RISCinstruction set and the X86 instruction set, so that a single programcan be coded in both, with freedom to call back and forth between thetwo. This approach is enabled by ISA bit 180, 182 control on converter136, and context saving in the exception handler (see sections II andIII, infra), or in an alternative embodiment, by ISA bit 180, 182,calling convention bit 200, semantic context record 206, and thecorresponding exception handlers (see section IV, infra). Second, an X86program may be translated into native RISC code, so that X86 programscan exploit many more of the speed opportunities available in a RISCinstruction set. This second approach is enabled by profiler 400, prober600, binary translator, and certain features of the memory manager (seesections V through VIII, infra). Third, these two approaches cooperateto provide an additional level of benefit.

Most of the features discussed in this disclosure are under a globalcontrol, a single bit in a processor control register named “PP_enable”(page properties enabled). When this bit is zero, ISA bit 180, 182 isignored and instructions are interpreted in Tapestry native mode,profiling is disabled, and probing is disabled.

B. The Tapestry Instruction Pipeline

Referring to FIG. 1 c, a Tapestry processor 100 implements an 8- or9-stage pipeline. Stage 1 (stage 110) fetches a line from I-cache 112.Stages 2 (Align stage 130) and 3 (Convert stage 134, 136, 138) operatedifferently in X86 and native Tapestry modes. In native mode, Alignstage 130 runs asynchronously from the rest of the pipeline, prefetchingdata from I-cache 112 into elastic prefetch buffer 132. In X86 mode,Align stage 130 partially decodes the instruction stream in order todetermine boundaries between the variable length X86 instructions, andpresents integral X86 instructions to Convert stage 134. During X86emulation, stage 3, Convert stage 134, 136 decodes each X86 instructionand converts 136 it into a sequence of native Tapestry instructions. Indecomposing an X86 instruction into native instructions, converter 136can issue one or two Tapestry instructions per cycle. Each Tapestryprocessor 100 has four parallel pipelined functional units 156, 158,160, 162 to implement four-way superscalar issue of the last five stagesof the pipeline. In native mode, convert stage 134, 138 determines up tofour independent instructions that can be executed concurrently, andissues them downstream to the four superscalar execution pipelines. (Inother machine descriptions, this is sometimes called “slotting,”deciding whether sufficient resources and functional units areavailable, and which instruction is to be issued to which functionalunit.) The Decode 140, Register-read 142, Address-Generate 144, Memory146, Execute 148, and Write-back 150 stages are conventional RISCpipeline stages.

Converter 136 decodes each X86 instruction and decomposes it into one ormore simple Tapestry instructions. The simple instructions are calledthe “recipe” for the X86 instruction.

Referring to Table 1, when X86 converter 136 is active, there is a fixedmapping between X86 resources and Tapestry resources. For instance, theEAX, EBX, ECX, EDX, ESP and EBP registers of the X86 architecture aremapped by converter hardware 136 to registers R48, R49, R50, R51, R52and R53, respectively, of the Tapestry physical machine. The eightfloating-point registers of the X86, split into a 16-bit sign andexponent, and a 64-bit fraction, are mapped to registers R32-47. The X86memory is mapped to the Tapestry memory, as discussed in section I.C,infra.

The use of the registers, including the mapping to X86 registers, issummarized in Table 1. The “CALL” column describes how the registers areused to pass arguments in the native Tapestry calling convention.(Calling conventions are discussed in detail in sections III.A, III.B,and IV, infra.) The “P/H/D” column describes another aspect of theTapestry calling convention, what registers are preserved across calls(if the callee subprogram modifies a register, it must save the registeron entry and restore it on exit), which are half-preserved (thelow-order 32 bits are preserved across calls, but the upper 32 bits maybe modified), and which are destroyable. The “X86 p/d” column showswhether the low-order 32 bits of the register, corresponding to a 32-bitX86 register, is preserved or destroyed by a call. The “Converter,”“Emulator” and “TAXi” columns show the mapping between Tapestryregisters and X86 registers under three different contexts. Forregisters r32-r47, “hi” in the X86 columns indicates that the registerholds a 16-bit sign and exponent portion of an X86 extended-precisionfloating-point value, and “lo” indicates the 64-bit fraction.

TABLE 1 Tap Tap X86 X86 X86 CALL P/H/D Description p/d ConverterEmulator TAXi r63 P — — — — r62 P — — — — r61 P — — — — r60 P — — — —r59 P — — — — r58 P — — — — r57 P — — — — r56 P — — — — r55 H X86 codewill preserve only low 32 bits p edi edi edi r54 H X86 code willpreserve only low 32 bits p esi esi esi r53 [FP] H must be Frame-Pointerif stack frame has variable size. p ebp ebp ebp r52 SP H stack pointer pesp esp esp r51 RV3 D if (192 bits < size <= 256 bits) fourth 64 bits offunction result d ebx ebx ebx r50 RV2 D X86_fastcall 2nd arg; d edx edxedx if (128 bits < size <= 256 bits) third 64 bits of function resultr49 THIS D X86_fastcall 1st arg; d ecx ecx ecx RV1 “thiscall” objectaddress (unadorned C++ non-static method); if (64 bits < size <= 256bits) second 64 bits of function result r48 RV0 D X86 function result deax eax eax first 64 bits of function result (unless it is DPfloating-point) r47 P15 D parameter register 15 f7-hi f7-hi f7-hi r46P14 D parameter register 14 f7-lo f7-lo f7-lo r45 P13 D parameterregister 13 f6-hi f6-hi f6-hi r44 P12 D parameter register 12 f6-lof6-lo f6-lo r43 P11 D parameter register 11 f5-hi f5-hi f5-hi r42 P10 Dparameter register 10 f5-lo f5-lo f5-lo r41 P9 D parameter register 9f4-hi f4-hi f4-hi r40 P8 D parameter register 8 f4-lo f4-lo f4-lo r39 P7D parameter register 7 f3-hi f3-hi f3-hi r38 P6 D parameter register 6f3-lo f3-lo f3-lo r37 P5 D parameter register 5 f2-hi f2-hi f2-hi r36 P4D parameter register 4 f2-lo f2-lo f2-lo r35 P3 D parameter register 3f1-hi f1-hi f1-hi r34 P2 D parameter register 2 f1-lo f1-lo f1-lo r33 P1D parameter register 1 f0-hi f0-hi f0-hi r32 P0 D parameter register 0f0-lo f0-lo f0-lo r31 RVA, D address of function result memory temporary(if any); Prof15 Prof15 RVDP DP floating-point function result r30 DProf14 Prof14 r29 D Prof13 Prof13 r28 D Prof12 Prof12 r27 D Prof11Prof11 r26 D Prof10 Prof10 r25 D Prof9 Prof9 r24 D Prof8 Prof8 r23 DProf7 Prof7 r22 D Prof6 Prof6 r21 D Prof5 Prof5 r20 D Prof4 Prof4 r19 DProf3 Prof3 r18 D Prof2 Prof2 r17 D Prof1 Prof1 r16 D Prof0 Prof0 r15 XDD Cross-ISA transfer descriptor (both call and return) RingBuf RingBufr14 D CT10 r13 D CT9 r12 D CT8 r11 D CT7 r10 D CT6 r9 D CT5 r8 D CT4 r7GP D pointer to global static environment (per-image) CT3 CT3 r6 LR Dlinkage register CT2 CT2 r5 AP D argument list pointer (overflowarguments in memory) CT1 CT1 r4 AT D AT r3 vol volatile, may only beused in exception handlers vol vol vol vol r2 vol volatile, may only beused in exception handlers vol vol vol vol r1 vol volatile, may only beused in exception handlers vol vol vol vol r0 n/a always zero n/a n/an/a n/a

Tapestry supersets many features of the X86. For instance, the Tapestrypage table format is identical to the X86 page table format; additionalinformation about page frames is stored in a Tapestry-private table, thePFAT (page frame attribute table) 172, as shown in FIG. 1 d. As will beshown in FIG. 1 e, the Tapestry PSW (Program Status Word) 190 embeds theX86 PSW 192, and adds several bits.

The Tapestry hardware does not implement the entire X86 architecture.Some of the more baroque and less-used features are implemented in asoftware emulator (316 of FIG. 3 a). The combination of hardwareconverter 136 and software emulator 316, however, yields a full andfaithful implementation of the X86 architecture.

C. Address Translation as a Control Point for System Features

Referring to FIG. 1 d, X86 address translation is implemented byTapestry's native address translation. During X86 emulation, nativevirtual address translation 170 is always turned on. Even when the X86is being emulated in a mode where X86 address translation is turned off,Tapestry address translation is turned on, to implement an identitymapping. By forcing every memory reference through the Tapestry addresstranslation hardware, address translation becomes a convenient place forintercepting much of the activity of X86 converter 136, and controllingthe converter's execution. Further, control information for manyfeatures of the invention is conveniently stored in tables associatedwith, or tables analogous to those conventionally used for, addresstranslation and virtual memory management. These “hooks” into addresstranslation allow the Tapestry processor and software to intervene toemulate portions of the X86 that have “strange” behavior, like VGAgraphics hardware, control registers, memory mapped device controls, andparts of the X86 address space that are given special treatment bytraditional Intel chip sets.

To avoid changing the meaning of any portion of storage that X86programs might be using, even if that use is unconventional, theTapestry processor does not store any of its information in the X86address translation tables. Tapestry-specific information about pages isstored in structures created specifically for Tapestry emulation of theX86. These structures are not defined in the X86 architecture, and areinvisible to the emulated X86 or any program executing on the X86. Amongthese structures are PFAT (page frame attribute table) 172. PFAT 172 isa table whose entries correspond to physical page frames and hold datafor processing and managing those page frames, somewhat analogous to thePFN (page frame number) database of the VAX/VMS virtual memory manager(see, e.g., Lawrence Kenah and Simon Bate, VAX/VMS Internals and DataStructures, Digital Press, 1984, incorporated herein by reference). PFAT172 has one 1-byte entry 174 corresponding to each physical page frame.

As will be discussed in sections II, IV, and V and VI, infra, PFATentries 174 also include bits that control which ISA is used to decodethe instructions of the corresponding page, which calling convention isused on the corresponding page, and to control probing.

D. Overview of Binary Translation, TAXi and the Converter Safety Net

Referring again to FIGS. 1 a and 1 b, TAXi (“Tapestry acceleratedexecution,” pronounced “TAXi”) is a binary translation system. TAXimarries two modes of execution, hardware converter 136 (with softwareassistance in the run-time system) that faithfully implements a goldstandard implementation of the full X86 architecture, and a softwarebinary translator 124 that translates X86 binaries to Tapestry nativebinaries, but optimizes the translated code by making certain optimisticassumptions that may violate correctness.

As a pre-existing X86 binary is executed in converter 136, hot spots(frequently-executed portions) in the X86 binary are recognized 122, andtranslated 124 on-the-fly into native Tapestry instructions. Thehardware converter 136 (coupled with a software X86 emulator 316 forespecially complex instructions) is necessarily slower than thetranslated code, because the X86 instructions must be executed in strictsequence. By translating complete hot spots of an X86 binary, as opposedto “translating” single instructions in converter 136, more optimizationopportunities are exposed: X86 instructions can be decomposed into smalldata-independent Tapestry instructions, which in turn can be executedout of order, pipelined, or executed in parallel in the four superscalarpipelines (156, 158, 160, 162 of FIG. 1 c).

Execution of X86 code is profiled. This profiling information is used toidentify 122 the “hot spots” in the X86 program, the most-executed partsof the program, and thus the parts that can most benefit fromtranslation into native Tapestry code. The hot spots in the X86 code aretranslated by translator 124 into native Tapestry code (TAXi code). Asexecution of the X86 program proceeds, execution is monitored todetermine whether a translated equivalent exists for the X86 code aboutto be executed. If so, execution is transferred to the translated nativeTapestry code.

TAXi translator 124 adopts a somewhat simplified view of the machinebehavior; for instance, some X86 instructions are not translated.Translator 124 also takes an optimistic view. For instance, translator124 assumes that there will be no floating-point exceptions or pagefaults, so that operations can be reordered or speculatively rescheduledwithout changing program behavior. Translator 124 also assumes that allmemory references are to well-behaved memory. (“Well-behaved memory” isa memory from which a load will receive the data last stored at thememory location. Non-well-behaved memory is typified by memory-mappeddevice controllers, also called “I/O space,” where a read causes thememory to change state, or where a read does not necessarily return thevalue most-recently written, or two successive reads return distinctdata.) For instance, binary translator 124 assumes that memory reads canbe reordered. Translated native Tapestry code runs faster than converter136, and is used when translation can be guaranteed to be correct, orwhen any divergence can be caught and corrected.

The execution of the TAXi code is monitored to detect violations of theoptimistic assumptions, so that any deviation from correct emulation ofthe X86 can be detected. Either a pre-check can detect that execution isabout to enter a region of translated code that can not be trusted toexecute correctly, or hardware delivers an exception after the fact whenthe optimistic assumptions are violated. In either case, whencorrectness cannot be guaranteed, or for code that translator 124 doesnot know how to translate, execution of the translated native Tapestrycode is aborted or rolled back to a safe check point, and execution isresumed in the hardware converter 136. The hardware converter 136 adoptsthe most conservative assumptions, guaranteeing in-order, gold standardcorrectness, and serves as a safety net for the less risk-averse binarytranslator 124.

This safety net paradigm allows binary translator 124 to be moreaggressive, and makes development easier, because developers can focuson performance issues and leave correctness issues to be caught in thesafety net. Additional details of the safety net paradigm are discussedin section VIII.

Tapestry and TAXi implement a full X86 architecture. No concession isrequired from X86 software; indeed, any X86 operating system can run onTapestry, including off-the-shelf operating systems not speciallyadapted for Tapestry. Tapestry and TAXi make no assumptions aboutoperating system entities, such as processes, threads, virtual addressspaces, address mappings. Thus, Tapestry and TAXi operate in terms ofthe physical memory of the virtual X86, not the X86 virtual or linearaddresses. (The distinction between Intel's “virtual” addresses and“linear” addresses seldom arises in the context of this disclosure;thus, unless a fine distinction between the two is required, thisdisclosure uses the term “virtual address” to embrace both concepts.)For instance, library code that is shared between different processes atthe operating system level, by using physical addresses, isautomatically shared by TAXi processes because the physical memory isshared on the Tapestry implementation. Code shared by the operatingsystem is shared even if it is mapped at different addresses indifferent processes. If the processes are actually sharing the samephysical page, then TAXi will share the same translated code.

Buffers of translated code are recycled in a first-in-first-out (FIFO)order. Once a translated code buffer is marked for reclamation, it isnot immediately discarded; rather it is marked available for reuse. Ifexecution re-enters an available-for-reuse buffer before the contentsare destroyed, the buffer is recycled to the head of the FIFO queue. Inan alternative embodiment, whenever the buffer is entered, it is movedto the head of the FIFO queue; this approximates a least-recently-used(LRU) replacement policy.

A number of features of the TAXi system are tied to profiling. Forinstance, a region of code that is not profiled can never be identifiedas a hot spot, and thus will never be translated. Similarly, probing(see section VI, infra) is disabled for any region that is not profiled,because without a translation, a probe can never succeed. This invariantsimplifies a number of design details, as will be discussed at variouspoints infra.

E. System-wide Controls

The PSW 190 has a TAXi_Active bit 198 that enables user-mode access tofunctionality that is otherwise disallowed in user mode. PSW.TAXi_Active198 will be set true while a native Tapestry translation of an X86program is being executed. When PSW.TAXi_Active 198 is true, a user-modeprogram may access the LDA/STA lock functionality of the X86, it hasread and write access to all Tapestry processor registers, and it mayaccess extended TRAP instruction vectors (specifically, to enablecalling emulator functions). Further, X86-compatible semantics forextended precision floating-point operations is enabled.

A successful probe will set PSW.TAXi_Active 198 before it RFE's to theTAXi-translated code. When the TAXi-translated code completes execution,the process of returning to untranslated X86 code will clearPSW.TAXi_Active 198 before RFE-ing back to converter 136. If anexception occurs in the TAXi-translated code, then emulator 316 will becalled to surface the exception back to the X86 virtual machine.Emulator 316 will check EPC.TAXi_Active 198 and return control to TAXito restore the X86 machine context and RFE back to converter 136 tore-execute the X86 instruction.

F. The XP Bit and the Unprotected Exception

Referring again to FIGS. 1 a, 1 b and 2 a, TAXi translator 124 producesa translation of an X86 binary. The TAXi system as a whole represents avery complex cache, where the X86 code represents the slower memorylevel and the translated TAXi code represents the faster memory level.TAXi begins caching information at the time of profiling, becauseprofiling records knowledge about what events occurred at whataddresses, where the instruction boundaries were, etc. Further cachingoccurs when binary translator 124 translates X86 code into semanticallyequivalent Tapestry native code. In order not to violate the X86architectural model, TAXi protects against execution of translatedTapestry native code that corresponds to stale X86 code, X86 code thathas either disappeared or been modified. If the underlying primary datum(the X86 instruction text) is modified, whether by a memory write fromthe CPU, or by a DMA write from a device, the cached data (the profiledescribing the X86 code and the TAXi code generated from it) isinvalidated, so that it will not be executed. Execution will revert tothe X86 text, in its modified form. If the modified X86 text becomes ahot spot, it may be recognized 122 and retranslated 124.

Like an ordinary cache, the TAXi cache has a valid bit—the XP bit (184in PIPM entry 640, 186 in the I-TLB, see FIGS. 1 a, 1 b). X86 code, andthe validity of the “cached” translated native Tapestry code, isprotected against modification by CPU writes by XP write-protect bit184, 186, and exception handlers that manage the protection of pages.Together, the flags and exceptions maintain a coherent translatedTapestry binary as a “cached” copy of the X86 program, while allowingthe X86 program (whether encoded in its original X86 form or intranslated native Tapestry form) to write to memory, even if that writeimplements self-modifying code. In either mode, the machine (either X86converter 136 or the TAXi system) will faithfully execute the program'ssemantics. The protected and unprotected exceptions do not terminateprocessing in the manner of a conventional write-protect exception, butmerely signal to the TAXi system that it must intervene to manage thevalidity of any TAXi code.

When a page of X86 code is protected, that is, when its XP protected bit184, 186 is One, there are two classes of events that invalidate theTAXi code associated with the X86 code. First, a Tapestry processorcould do a store into one of the X86 pages. This could arise if theprogram uses self-modifying code, or if the program creates code inwriteable storage (stack or heap) on the fly. Second, a DMA device couldwrite onto the page, for instance, when a page of program text is pagedin on a page fault following a program load or activation. In eithercase, Tapestry generates an interrupt, and a handler for the interruptresets the XP “valid” bit to indicate that any TAXi code correspondingto the X86 page cannot be reached by a probe (recall from section VI.Dthat probing is only enabled on X86 pages whose XP bit 184, 186 is One).

The write-protect bit is named “XP,” originally an acronym for “extendedproperty.” Thus, when ISA bit (180 in PFAT 172, 182 in I-TLB) for a pageindicates X86 ISA, the XP bit (184 in PIPM entry 640, 186 in the I-TLB)is interpreted to encode the modify-protect property for the page. XPbit 184, 186 controls the protection mechanism on a page-by-pagegranularity. The protection system for the machine as a whole is enabledand disabled by the TAXi_Control.unpr bit (bit <60> of the TAXi_Controlregister, 468 of FIG. 4 g, see section V.E, infra).

Physical pages are divided for management between Tapestry operatingsystem (312 of FIG. 3 a) and X86 operating system 306, and PFAT.ISA bit180 for the page (which is cached in the I-TLB.ISA bit 182) is setaccordingly, Zero for Tapestry, One for X86. For all X86 pages, the XPbit (184 in PFAT 172, 186 in I-TLB 116) is cleared to Zero to indicate“unprotected.” XP bit 184, 186 has no effect on Tapestry pages.

XP bit 184, 186 behaves somewhat analogously to a MESI (Modified,Exclusive, Shared, Invalid) cache protocol. The XP “unprotected” stateis roughly equivalent to the MESI “Exclusive” state, and means that noinformation from this page may be cached while the page remainsunprotected. The “protected” XP state is roughly equivalent to the MESI“Shared” state, and means that information from the page may be cached,but cached information must be purged before the page can be written.Four points of the analogy are explained in Table 2.

TABLE 2 fetch for sharing write MESI Shared cached action 1 Exclusiveuncached/exclusive action 2 3 TAXi XP protection Protected action 1Unprotected uncached/exclusive action 2 3 action 1: discard all cachedcopies of the data, transition to the uncached/exclusive state action 2:fetch a shared/duplicate copy, and transition to the cached/sharedstate.

A write to a MESI “Shared” cache line forces all other processors topurge the cache line, and the line is set to “Exclusive.” Analogously, awrite to an XP-protected 184, 186 page causes the page to be set tounprotected. These two analogous actions are designated “action 1” intable 2. If a page's ISA bit 180, 182 is One and XP bit 184, 186 is One,then this is an X86 instruction page that is protected. Any store to anX86 ISA page whose XP bit 184, 186 is One (protected), whether thecurrent code is X86 native code or TAXi code, is aborted and control ispassed to the protected exception handler. The handler marks the pageunprotected by setting the page's XP bit 184, 186 to Zero. Any TAXi codeassociated with the page is discarded, and PIPM database 602 that tracksthe TAXi code is cleaned up to reflect that discarding. Then the storeis retried—it will now succeed, because the page's XP bit 184, 186 hasbeen cleared to Zero (unprotected). If TAXi code writes onto the X86page of which this TAXi code is the translation, then the generalmechanism still works—the exception handler invalidates the TAXi codethat was running, and will return to the converter and original X86 textinstead of the TAXi code that executed the store.

A write to a “Exclusive” cache line, or to an XP-unprotected 184, 186page, induces no state change. If XP bit 184, 186 is Zero (unprotected),then stores are allowed to complete. These two states are labeled “3” inTable 2.

A read from a MESI “Shared” cache line proceeds without further delay,because the data in the cache are current. Analogously, converter 136execution of an instruction from an XP-protected 184, 186 page proceedswithout delay, because if any translated TAXi code has been generatedfrom the instructions on the page, the TAXi code is current, and theprofiling and probing mechanisms (400, 600, see sections V and VI,infra) will behave correctly. These analogous responses are labeled “4”in Table 2.

A read from a cache line, where that cache line is held in anotherprocessor in “Exclusive” state, forces the cache line to be stored tomemory from that other processor, and then the line is read into thecache of the reading processor in “Shared” state. Analogously, whenconverter 136 executes code from XP-unprotected 184, 186 page (ISA isOne, representing X86 code, and XP bit 184, 186 is Zero, indicatingunprotected), and is about to write a profile trace-packet entry, withcertain additional conditions, the machine takes an “unprotected”exception and vectors to the corresponding handler. The handler makesthe page protected and synchronizes that page with other processors.These analogous actions are labeled “action 2” in Table 2. Anunprotected exception is raised when an instruction is fetched from anunprotected X86 page (the page's I-TLB.ISA bit 182 is One, see sectionII, infra, and I-TLB.XP 186 bit is Zero), and TAXi_Control.unpr 468 isOne and either of the following:

-   -   (1) a profile capture instruction is issued to start a new        profile packet (TAXi_State.Profile_Active (482 of FIG. 4 h) is        Zero, TAXi_State.Profile_Request 484 is One, and        TAXi_State.Event_Code_Latch 486, 487 contains an event code for        which “initiate packet” 418 is True in FIG. 4 b), or    -   (2) when the first instruction in a converter recipe is issued        and TAXi_State.Profile_Active 482 is One.        The TAXi_State terms of this equation are explained in sections        V.E and V.F and FIGS. 4 g, 4 h, 5 a and 5 b.

The unprotected exception handler looks up the physical page address ofthe fetched instruction from the EPC.EIP (the EPC is the nativeexception word (instruction pointer and PSW) pushed onto the stack bythe exception, and EPC.EIP is the instruction pointer value), or from aTLB fault address processor register. The interrupt service routine setsthe PFAT.XP bit 184 and I-TLB.XP bit 186 for the page to One, indicatingthat the page is protected. This information is propagated to the otherTapestry processors and DMU (DMA monitoring unit) 700, in a mannersimilar to a “TLB shoot-down” in a shared-memory multiprocessor cachesystem. The exception handler may either abort the current profilepacket (see section V.F, infra), or may put the machine in a contextfrom which the profile packet can be continued. Then the exceptionhandler returns to converter 136 to resume execution.

When TAXi_Control.unpr (468 of FIG. 4 g) is clear, then the value of theXP bit 184, 186 is ignored: no exception is generated and TAXi softwareis responsible for validating the profile packet and setting the“Protected” page attribute.

In an alternative embodiment, the unprotected exception handler abortsthe current profile packet, and enqueues the identity of the page.Later, a lazy agent, analogous to a page purifier in a virtual memorysystem, manipulates the PFAT.XP bit 184, I-TLB.XP bit 186, and DMU (DMAmonitoring unit) to protect the page. When execution next enters thepage, the page will be protected, and profiling proceeds in the normalcourse.

Attempts to write to a protected page (for instance, by self-modifyingcode, or a write to a mixed text-and-data page) will be trapped, and thepage will be set unprotected again.

Profiling is effectively disabled for unprotected pages, because anattempt to profile on an unprotected page, while TAXi_Control.unpr 468is One, raises an unprotected exception, and the unprotected exceptionhandler either makes the page protected, or aborts the profile packet.Turning off profiling for unprotected pages ensures that an unprotectedpage will not be recognized as a hot spot, and thus not translated.Conversely, if a page cannot be protected (for instance, the page is notthe well-behaved memory of address space zero, but rather is mapped toan I/O bus), then any profile packet currently being collected isaborted. The implementation of this rule, and some limited exceptions,are discussed in section V.H, infra.

Further details of the XP protection mechanism are discussed in VIII,infra. A second protection mechanism, for protecting pages againstwrites by DMA devices, is described in section VII, infra.

II. Indicating the Instruction Set Architecture (ISA) for Program Text

Referring to FIGS. 1 a, 1 b, 1 c and 1 d, a program is divided intoregions 176, and each region has a corresponding flag 180. Flag 180asserts 178 an ISA under which instruction; decode unit 134, 136, 140 isto decode instructions from the corresponding region. For instance, theaddress space is divided into pages 176 (the same pages used for virtualmemory paging), and ISA bit 180 in a page table entry (PTE) asserts theISA to be used for the instructions of the page. When instructions arefetched from a page 176 whose ISA bit 180, 182 is a Zero, theinstructions are interpreted as Tapestry native instructions and fed 138by ISA select 178 directly to pipeline 120. When instructions arefetched from a page 176 whose ISA bit 180, 182 is a One, theinstructions are fed under control of ISA select 178 to Convert stage134, 136 of the pipeline, which interprets instructions as Intel X86instructions. The regions need not be contiguous, either in virtualmemory or in physical memory—regions of X86 text can be intermingledwith regions of native Tapestry text, on a page-by-page basis.

A program written for one ISA can call library routines coded in eitherISA. For instance, a particular program may use both a databasemanagement system and multimedia features. The multimedia services mightbe provided by libraries in optimized Tapestry native code. The databasemanager may be an off-the-shelf database system for the X86. The callingprogram, whether compiled for the X86 or for Tapestry, can readily callboth libraries, and the combination will seamlessly cooperate.

In one embodiment, ISA bit is instantiated in two places, a master copy180 and a cached copy 182 for fast access. The master copy is a singlebit 180 in each entry 174 in PFAT 172. There is one PFAT entry 174corresponding to each physical page of the memory 118, and the value ofthe value of ISA bit 180 in a given PFAT entry 174 controls whetherTapestry processor 100 will interpret instructions fetched from thecorresponding page under the native instruction set architecture or asX86 instructions. On an I-TLB miss, the PTE from the Intel-format pagetables is loaded into the I-TLB, as cached copy 182. The physical pageframe number from the page table entry is used to index into PFAT 172,to find the corresponding PFAT entry 174, and information from the PFATentry 174 is used to supplement the Intel-format I-TLB entry. Thus, bythe time the bit is to be queried during an instruction fetch 110, theISA bit 180 bit is in its natural location for such a query, I-TLB 116.Similarly, if the processor uses a unified instruction and data TLB, thepage table and PFAT information are loaded into the appropriate entry inthe unified TLB.

In alternative embodiments, ISA bit 180 may be located in the addresstranslation tables, whether forward-mapped or reverse-mapped. Thisembodiment may be more desirable in embodiments that are lessconstrained to implement a pre-existing fixed virtual memoryarchitecture, where the designers of the computer have more control overthe multiple architectures to be implemented. In another alternative,ISA bit 180, 182 may be copied as a datum in I-cache 112.

When execution flows from a page of one ISA 180, 182 to a page ofanother (e.g., when the source of a control flow transfer is in one ISAand the destination is in the other), Tapestry detects the change, andtakes a exception, called a “transition exception.” The exceptionvectors the processor to one of two exception handlers, aTapestry-to-X86 handler (340 of FIG. 3 i) or an X86-to-Tapestry handler(320 of FIG. 3 h), where certain state housekeeping is performed. Inparticular, the exception handler changes the ISA bit 194 in the EPC(the copy of the PSW that snapshots the state of the interrupted X86process), so that the RFE (return from exception instruction) at the endof the transition exception handler 320, 340 will load the alteredEPC.ISA bit 194 into the PSW. The content of the PSW.ISA bit 194 is thestate variable that controls the actual execution of the processor 100,so that the changed ISA selection 178 takes effect when executionresumes. The PFAT.ISA copy 180 and I-TLB.ISA copy 182 are mere triggersfor the exceptions. The exception mechanism allows the instructions inthe old ISA to drain from the pipeline, reducing the amount of controlcircuitry required to effect the change to the new ISA mode ofexecution.

Because the Tapestry and X86 architectures share a common datarepresentation (both little endian, 32-bit addresses, IEEE-754floating-point, structure member alignment rules, etc.), the process canresume execution in the new ISA with no change required to the datastorage state of the machine.

In an alternative embodiment, the execution of the machine is controlledby the I-TLB.ISA copy of the bit ISA bit 194, and the PSW.ISA copy 190is a history bit rather than a control bit. When execution flows onto apage whose ISA bit 180, 182 does not match the ISA 180, 182 of theprevious page, at the choice of the implementer, the machine may eithertake a transition exception, or “change gears” without taking atransition exception.

There is a “page properties enable” bit in one of the processor controlregisters. On system power-on, this bit is Zero, disabling the pageproperties. In this state, the PSW.ISA bit is manipulated by software toturn converter 136 on and off, and transition and probe exceptions aredisabled. As system initialization completes, the bit is set to One, andthe PFAT and TLB copies of the ISA bit control system behavior asdescribed supra.

III. Saving Tapestry Processor Context in Association with an X86 Thread

A. Overview

Referring to FIGS. 3 a-3 f, the ability to run programs in either of twoinstruction sets opens the possibility that a single program might becoded in both instruction sets. As shown in FIG. 3 b, the Tapestrysystem provides transparent calls from caller to callee, without eitherknowing the ISA of the other, without either caller or callee beingspecially coded to work with the other. As shown in FIG. 3 c, an X86caller 304 might make a call to a callee subprogram, without beingconstrained to work with only callees coded in the X86 instruction setor the native tapestry RISC instruction set 308. If the callee is codedin the X86 instruction set, the call will execute as a normal call. Ifthe callee 308 is coded in the native Tapestry instruction set, thenTapestry processor 100 will take a transition exception 384 on entry tothe callee 308, and another transition exception 386 on returning fromthe Tapestry callee 308 to the X86 caller 304. These transitionexceptions 384, 386 and their handlers (320 of FIG. 3 h and 340 of FIG.3 i) convert the machine state from the context established by the X86caller to the context expected by the Tapestry callee 308.

Referring to FIGS. 3 c-3 f, analogous transition exceptions 384, 386 andhandlers 320, 340 provide the connection between an X86 caller and itscallees (FIG. 3 c), a native Tapestry caller and its callees (FIG. 3 d),between an X86 callee and its callers (FIG. 3 e), and between a nativeTapestry callee its callers (FIG. 3 f), and provides independencebetween the ISA of each caller-callee pair.

Referring to FIGS. 3 a and 3 l and to Table 1, X86 threads (e.g., 302,304) managed by X86 operating system 306, carry the normal X86 context,including the X86 registers, as represented in the low-order halves ofr32-r55, the EFLAGS bits that affect execution of X86 instructions, thecurrent segment registers, etc. In addition, if an X86 thread 302, 304calls native Tapestry libraries 308, X86 thread 302, 304 may embody agood deal of extended context, the portion of the Tapestry processorcontext beyond the content of the X86 architecture. A thread's extendedcontext may include the various Tapestry processor registers, generalregisters r1-r31 and r56-r63, and the high-order halves of r32-r55 (seeTable 1), the current value of ISA bit 194 (and in the embodiment ofsection IV, infra, the current value of XP/calling convention bit 196and semantic context field 206).

The Tapestry system manages an entire virtual X86 310, with all of itsprocesses and threads, e.g., 302, 304, as a single Tapestry process 311.Tapestry operating system 312 can use conventional techniques for savingand restoring processor context, including ISA bit 194 of PSW 190, oncontext switches between Tapestry processes 311, 314. However, forthreads 302, 304 managed by an off-the-shelf X86 operating system 306(such as Microsoft Windows or IBM OS/2) within virtual X86 process 311,the Tapestry system performs some additional housekeeping on entry andexit to virtual X86 310, in order to save and restore the extendedcontext, and to maintain the association between extended contextinformation and threads 302, 304 managed by X86 operating system 306.(Recall that Tapestry emulation manager 316 runs beneath X86 operatingsystem 306, and is therefore unaware of entities managed by X86operating system 306, such as processes and threads 302, 304.)

FIGS. 3 a-3 o describe the mechanism used to save and restore the fullcontext of an X86 thread 304 (that is, a thread that is under managementof X86 operating system 306, and thus invisible to Tapestry operatingsystem 312) that is currently using Tapestry extended resources. Inoverview, this mechanism snapshots the full extended context into amemory location 355 that is architecturally invisible to virtual X86310. A correspondence between the stored context memory location 355 andits X86 thread 304 is maintained by Tapestry operating system 312 andX86 emulator 316 in a manner that that does not require cooperation ofX86 operating system 306, so that the extended context will be restoredwhen X86 operating system 306 resumes X86 thread 304, even if X86operating system 306 performs several context switches among X86 threads302 before the interrupted X86 thread 304 resumes. The X86 emulator 316or Tapestry operating system 312 briefly gains control at eachtransition from X86 to Tapestry or back, including entries to andreturns from X86 operating system 306, to save the extended context andrestore it at the appropriate time.

The description of the embodiment of FIGS. 3 g-3 k, focuses on crossingsfrom one ISA to the other under defined circumstances (subprogram callsand returns and interrupts), rather than the fully general case ofallowing transitions on any arbitrary transfer (conditional jumps andthe like). Because there is always a Tapestry source or destination atany cross-ISA transfer, and the number of sites at which such a transfercan occur is relatively limited, the Tapestry side of each transitionsite can be annotated with information that indicates the steps to taketo convert the machine state from that established in the source contextto that expected in the destination context. In the alternativeembodiment of section IV, the hardware supplements this softwareannotation, to allow the fully general ISA crossing.

The interaction between the native Tapestry and X86 environments iseffected by the cooperation of an X86-to-Tapestry transition exceptionhandler (320 of FIG. 3 h), a Tapestry-to-X86 transition exceptionhandler (340 of FIG. 3 i), interrupt/exception handler (350 of FIG. 3 j)of Tapestry operating system 312, and X86 emulator 316 (the softwarethat emulates the portions of the X86 behavior that are not convenientlyexecuted in converter hardware 136).

Because all native Tapestry instructions are naturally aligned to a 0mod 4 boundary, the two low-order bits <1:0> of a Tapestry instructionaddress are always known to be Zero. Thus, emulator 316, and exceptionhandlers 320, 340, 350 of Tapestry operating system 312, can passinformation to each other in bits <1:0> of a Tapestry instructionaddress. To consider an example, the return address of a call fromnative Tapestry code, or the resume address for an interrupt of nativecode, will necessarily have two Zeros in its least significant bits. Thecomponent that gains control (either Tapestry-to-X86 transition handler340 or Tapestry operating system 312) stores context information inthese two low-order bits by setting them as shown in Table 3:

TABLE 3 00 default case, where X86 caller set no value of these bits -by elimination, this means the case of calling a native Tapestrysubprogram 01 resuming an X86 thread suspended in a native Tapestrysubprogram 10 returning from an X86 callee to a native Tapestry caller,result already in register(s) 11 returning from an X86 callee to anative Tapestry caller, where the function result is in memory asspecified in the X86 calling convention, and is to be copied intoregisters as specified by the Tapestry calling convention.Then, when control is to be returned to a Tapestry caller or tointerrupted Tapestry native code, X86-to-Tapestry transition handler 320uses these two bits to determine the context of the caller that is to berestored, and restores these two bits to Zero to return control to thecorrect address.

A second information store is the XD register (register R15 of Table 1).The Tapestry calling convention (see section III.B, infra) reserves thisregister to communicate state information, and to provide a descriptionof a mapping from a machine state under the X86 calling convention to asemantically-equivalent machine context under the Tapestry convention,or vice-versa. The Tapestry cross-ISA calling convention specifies thata caller, when about to call a callee subprogram that may be coded inX86 instructions, sets the XD register to a value that describes thecaller's argument list. Similarly, when a Tapestry callee is about toreturn to what may be an X86 caller, the calling convention requires thecallee to set XD to a value that describes the return value returned bythe function. From that description, software can determine how thatreturn value should be converted for acceptance by the callee under theX86 calling convention. In each case, the XD value set by the Tapestrycode is non-zero. Finally, X86-to-Tapestry transition handler 320 setsXD to zero to indicate to the Tapestry destination that the argumentlist is passed according to the X86 calling convention. As will bedescribed further infra, each Tapestry subprogram has a prolog thatinterprets the XD value coming in, to convert an X86 calling conventionargument list into a Tapestry calling convention argument list (if theXD value is zero), and Tapestry-to-X86 exception handler 340 isprogrammed to interpret the XD value returned from a Tapestry functionto convert the function return value into X86 form.

The Tapestry calling convention requires a callee to preserve thecaller's stack depth. The X86 convention does not enforce such arequirement. X86-to-Tapestry transition handler 320 and Tapestry-to-X86transition handler 340 cooperate to enforce this discipline on X86callees. When Tapestry-to-X86 transition handler 340 detects a call toan X86 callee, transition handler 340 records (343 of FIG. 3 i) thestack depth in register ESI (R54 of Table 1). ESI is half-preserved bythe X86 calling convention and fully preserved by the native convention.On return, X86-to-Tapestry transition handler 320 copies ESI back to SP,thereby restoring the original stack depth. This has the desiredside-effect of deallocating any 32 byte hidden temporary created (344 ofFIG. 3 i) on the stack by Tapestry-to-X86 transition handler 340.

B. Subprogram Prologs

A “calling convention” is simply an agreement among software componentsfor how data are to be passed from one component to the next. If alldata were stored according to the same conventions in both the nativeRISC architecture and the emulated CISC architecture, then a transitionbetween two ISA environments would be relatively easy. But they do not.For instance, the X86 calling convention is largely defined by the X86architecture. Subroutine arguments are passed on a memory stack. Aspecial PUSH instruction pushes arguments onto the stack before asubprogram call, a CALL instruction transfers control and saves thereturn linkage location on the stack, and a special RET (return)instruction returns control to the caller and pops the callee's datafrom the stack. Inside the callee program, the arguments are referencedat known offsets off the stack pointer. On the other hand, the Tapestrycalling convention, like most RISC calling conventions, is defined byagreement among software producers (compilers and assembly languageprogrammers). For instance, all Tapestry software producers agree thatthe first subprogram argument will be passed in register 32, the secondin register 33, the third in register 34, and so on.

Referring to FIG. 3 g, any subprogram compiled by the Tapestry compilerthat can potentially be called from an X86 caller is provided with botha GENERAL entry point 317 and a specialized NATIVE entry point 318.GENERAL entry point 317 provides for the full generality of being calledby either an X86 or a Tapestry caller, and interprets 319 the value inthe XD register (R15 of Table 1) to ensure that its parameter listconforms to the Tapestry calling convention before control reaches thebody of the subprogram. GENERAL entry point 317 also stores someinformation in a return transition argument area (RXA, 326 of FIG. 3 h)of the stack that may be useful during return to an X86 caller,including the current value of the stack pointer, and the address of ahidden memory temp in which large function return values might bestored. NATIVE entry point 318 can only be used by Tapestry callersinvoking the subprogram by a direct call (without going through apointer, virtual function, or the like), and provides for amore-efficient linkage; the only complexities addressed by NATIVE entrypoint 318 are varargs argument lists, or argument lists that do not fitin the sixteen parameter registers P0-P15 (R32-R47 of Table 1). Thevalue of GENERAL entry point 317 is returned by any operation that takesthe address of the subprogram.

C. X86-to-Tapestry Transition Handler

Referring to FIG. 3 h, X86-to-Tapestry transition handler 320 is enteredunder three conditions: (1) when code in the X86 ISA calls nativeTapestry code, (2) when an X86 callee subprogram returns to a nativeTapestry caller, and (3) when X86 operating system 306 resumes a thread304 that was interrupted by an asynchronous external interrupt whileexecuting native Tapestry code.

X86-to-Tapestry transition handler 320 dispatches 321 on the two-loworder bits of the destination address, as obtained in EPC.EIP to code tohandle each of these conditions. Recall that these two bits were set tovalues reflected in Table 3, supra.

If those two low-order bits EPC<01:00> are “00,” case 322, thisindicates that this transition is a CALL from an X86 caller to aTapestry callee (typically a Tapestry native replacement for a libraryroutine that that caller expected to be coded in X86 binary code).Transition handler 320 pops 323 the return address from the memory stackinto the linkage register LR (register R6 of Table 1). Pop 323 leaves SP(the stack pointer, register R52 of Table 1) pointing at the firstargument of the X86 caller's argument list. This SP value is copied 324into the AP register (the argument pointer, register R5 of Table 1). SPis decremented 326 by eight, to allocate space for a return transitionargument area (the return transition argument area may be used by theGENERAL entry point (317 of FIG. 3 g) of the callee), and then the SP isrounded down 327 to 32-byte alignment. Finally, XD is set 328 to Zero toinform the callee's GENERAL entry point 317 that this call is arrivingwith the machine configured according to the X86 calling convention.

If the two low-order bits of the return address EPC<01:00> are “10” or“11,” cases 329 and 332, this indicates a return from an X86 callee to aTapestry caller. These values were previously stored into EPC<01:00> byTapestry-to-X86 transition handler 340 at the time the X86 callee wascalled, according to the nature of the function return result expected.

Low-order bits of “11,” case 329, indicate that the X86 callee created alarge function result (e.g., a 16-byte struct) in memory, as specifiedby the X86 calling convention. In this case, transition handler 320loads 330 the function result into registers RV0-RV3 (registers R48-R51—see Table 1) as specified by the Tapestry calling convention. Low-orderbits of “10,” case 332, indicate that the function result is already inregisters (either integer or FP).

In the register-return-value “10” case 332, X86-to-Tapestry transitionhandler 320 performs two register-based conversions to move the functionreturn value from its X86 home to its Tapestry home. First, transitionhandler 320 converts the X86's representation of an integer result(least significant 32 bits in EAX, most significant 32 bits in EDX) intothe native convention's representation, 64 bits in RV0 (R48 of Table 1).Second, transition handler 320 converts 334 the X86's 80-bit value atthe top of the floating-point stack into the native convention's 64-bitrepresentation in RVDP (the register in which double-precisionfloating-point results are returned, R31 of Table 1).

The conversion for 64-bit to 80-bit floating-point is one example of achange in bit representation (as opposed to a copy from one location toanother of an identical bit pattern) that may be used to convert theprocess context from its source mode to a semantically-equivalent formin its destination mode. For instance, other conversions could involvechanging strings from an ASCII representation to EBCDIC or vice-versa,changing floating-point from IBM base 16 format to Digital's proprietaryfloating-point format or an IEEE format or another floating-pointformat, from single precision to double, integers from big-endian tolittle-endian or vice-versa. The type of conversion required will varydepending on the characteristics of the native and non-nativearchitectures implemented.

In the “01” case 370 of resuming an X86 thread suspended during a callout to a native Tapestry subprogram, transition handler 320 locates therelevant saved context, confirms that it has not been corrupted, andrestores it (including the true native address in the interrupted nativeTapestry subprogram). The operation of case 370 will be described infurther detail in sections III.F and III.G, infra.

After the case-by-case processing 322, 329, 332, 370, the two low-orderbits of return address in EPC<1:0> (the error PC) are reset 336 to “00”to avoid a native misaligned I-fetch fault. At the end of cases 329 and332, Register ESI (R54 of Table 1) is copied 337 to SP, in order toreturn to the stack depth at the time of the original call. An RFEinstruction 338 resumes the interrupted program, in this case, at thetarget of the ISA-crossing control transfer.

D. Tapestry-to-X86 Transition Handler

Referring to FIG. 3 i, Tapestry-to-X86 handler 340 is entered under twoconditions: (1) a native Tapestry caller calls an X86 callee, or (2) anative Tapestry callee returns to an X86 caller. In either case, thefour low-order bits XD<3:0> (the transfer descriptor register, R15 ofTable 1) were set by the Tapestry code to indicate 341 the steps to taketo convert machine context from the Tapestry calling convention to theX86 convention.

If the four low-order bits XD<03:00> direct 341 a return from a Tapestrycallee to an X86 caller, the selected logic 342 copies any functionreturn value from its Tapestry home to the location specified by the X86calling convention. For instance, XD may specify that a 64-bit scalarinteger result returned in RV0 is to be returned as a scalar in EAX orin the EDX:EAX register pair, that a double-precision floating-pointresult is to be copied from RV0 to the top of the X86 floating-pointstack as an 80-bit extended precision value, or that a large returnvalue being returned in RV0-RV3 (R48-R51 of Table 1) is to be copied tothe memory location specified by original X86 caller and saved in theRXA. The stack depth is restored using the stack cutback valuepreviously saved in the RXA by the GENERAL entry point prolog 317.

If a Tapestry caller expects a result in registers but understands underthe X86 calling convention that an X86 function with the same prototypewould return the result via the RVA mechanism (returning a return valuein a memory location pointed to by a hidden first argument in theargument list), the Tapestry caller sets XD<3:0> to request thefollowing mechanism from handler 340. The caller's stack pointer iscopied 343 to the ESI register (R54 of Table 1) to ensure that the stackdepth can be restored on return. A naturally-aligned 32-byte temporaryis allocated 344 on the stack and the address of that temporary is usedas the RVA (R31 of Table 1) value. Bits LR<1:0> are set 345 to “11” torequest that X86-to-Tapestry transition handler 320 load 32 bytes fromthe allocated buffer into RV0-RV3 (R48-R51 of Table 1) when the X86callee returns to the Tapestry caller.

For calls that will not use the RVA mechanism (for instance, the calleewill return a scalar integer or floating-point value, or no value atall), Tapestry-to-X86 transition handler 340 takes the followingactions. The caller's stack pointer is copied 343 to the ESI register(R54 of Table 1) to ensure that the stack depth can be restored onreturn. Bits LR<1:0> are set 346 to “10” as a flag to X86-to-Tapestrytransition handler 320, 332 on returning to the native caller. Forcalls, handler 340 interprets 347 the remainder of XD to copy theargument list from the registers of the Tapestry calling convention tothe memory locations of the X86 convention. The return address (LR) ispushed onto the stack.

For returns from Tapestry callees to X86 callers, the X86 floating-pointstack and control words are established.

Tapestry-to-X86 transition handler 340 concludes by establishing 348other aspects of the X86 execution environment, for instance, setting upcontext for emulator 316 and profiler 400. An RFE instruction 349returns control to the destination of the transfer in the X86 routine.

E. Handling ISA Crossings on Interrupts or Exceptions in the TapestryOperating System

Referring to FIG. 3 j in association with FIGS. 3 a and 3 l, mostinterrupts and exceptions pass through a single handler 350 in Tapestryoperating system 312. At this point, a number of housekeeping functionsare performed to coordinate Tapestry operating system 312, X86 operatingsystem 306, processes and threads 302, 304, 311, 314 managed by the twooperating systems 306, 312, and the data configuration of thoseprocesses and threads that may need to be altered to pass from onecalling convention to the other.

A number of interrupts and exceptions are skimmed off and handled bycode not depicted in FIG. 3 j. This includes all interrupts directed tosomething outside virtual X86 310, including all synchronous exceptionsraised in other Tapestry processes, the interrupts that drivehousekeeping functions of the Tapestry operating system 312 itself(e.g., a timer interrupt), and exceptions raised by a Tapestry nativeprocess 314 (a process under the management of Tapestry operating system312). Process-directed interrupts handled outside FIG. 3 j includeasynchronous interrupts, the interrupts not necessarily raised by thecurrently-executing process (e.g., cross-processor synchronizationinterrupts). These interrupts are serviced in the conventional manner inTapestry operating system 312: the full Tapestry context of the threadis saved, the interrupt is serviced, and Tapestry operating system 312selects a thread to resume.

Thus, by the time execution reaches the code shown in FIG. 3 j, theinterrupt is guaranteed to be directed to something within virtual X86310 (for instance, a disk completion interrupt that unblocks an X86thread 302, 304, or a page fault, floating-point exception, or an INTsoftware interrupt instruction, raised by an X86 thread 302, 304), andthat this interrupt must be reflected from the Tapestry handlers to thevirtual X86 310, probably for handling by X86 operating system 306.

Once X86 operating system 306 gains control, there is a possibility thatX86 operating system 306 will context switch among the X86 processes302, 304. There are two classes of cases to handle. The first classembraces cases 351, 353, and 354, as discussed further infra. In thisclass of cases, the interrupted process has only X86 state that isrelevant to save. Thus, the task of maintaining the association betweencontext and thread can be handed to the X86 operating system 306: thecontext switch mechanism of that operating system 306 will perform inthe conventional manner, and maintain the association between contextand process. On the other hand, if the process has extended context thatmust be saved and associated with the current machine context (e.g.,extended context in a Tapestry library called on behalf of a processmanaged by X86 OS), then a more complex management mechanism must beemployed, as discussed infra in connection with case 360.

If the interrupted thread was executing in converter 136, as indicatedby ISA bit 194 of the EPC, then the exception is handled by case 351.Because the interrupted thread is executing X86 code entirely within thevirtual X86, the tasks of saving thread context, servicing theinterrupt, and selecting and resuming a thread can be left entirely toX86 operating system 306. Thus, Tapestry operating system 306 calls the“deliver interrupt” routine (352 of FIG. 3 a) in X86 emulator 316 toreflect the interrupt to virtual X86 310. The X86 operating system 306will receive the interrupt and service it in the conventional manner.

If an interrupt is directed to something within virtual X86 310, whileTAXi code (a translated native version of a “hot spot” within an X86program, see section I.D, supra, as indicated by the TAXi_Active bit 198of the EPC) was running, then the interrupt is handled by case 353.Execution is rolled back to an X86 instruction boundary. At an X86instruction boundary, all Tapestry extended context external to the X86310 is dead, and a relatively simple correspondence betweensemantically-equivalent Tapestry and X86 machine states can beestablished. Tapestry execution may be abandoned—after the interrupt isdelivered, execution may resume in converter 136. Then, if the interruptwas an asynchronous external interrupt, TAXi will deliver theappropriate X86 interrupt to the virtual X86 supplying the reconstructedX86 machine state, and the interrupt will be handled by X86 operatingsystem 306 in the conventional manner. Else, the rollback was induced bya synchronous event, so TAXi will resume execution in converter 136, andthe exception will be re-triggered, with EPC.ISA 194 indicating X86, andthe exception will be handled by case 351.

If the interrupted thread was executing in X86 emulator 316, asindicated by the EM86 bit of the EPC, the interrupt is handled by case354. This might occur, for instance, when a high-priority X86 interruptinterrupts X86 emulator 316 while emulating a complex instruction (e.g.¢> far call through a gate) or servicing a low-priority interrupt. Theinterrupt is delivered to emulator 316, which handles the interrupt.Emulator 316 is written using re-entrant coding to permit re-entrantself-interruption during long-running routines.

Case 360 covers the case where the interrupt or exception is directed tosomething within virtual X86 310, and the current thread 304, though anX86 thread managed by X86 operating system 306, is currently executingTapestry code 308. For instance, an X86 program may be calling a nativeTapestry library. Here, the interrupt or exception is to be serviced byX86 operating system 306, but the thread currently depends on Tapestryextended context. In such a case, X86 operating system 306 may perform acontext switch of the X86 context, and the full Tapestry context willhave to be restored when this thread is eventually resumed. However, X86operating system 306 has no knowledge of (nor indeed has itaddressability to) any Tapestry extended context in order to save it,let alone restore it. Thus, case 360 takes steps to associate thecurrent Tapestry context with the X86 thread 304, so that the fullcontext will be re-associated (by code 370 of FIG. 3 h) with thread 304when X86 operating system 306 resumes the thread's execution.

Referring briefly to FIG. 3 k, during system initialization, theTapestry system reserves a certain amount of nonpageable storage to useas “save slots” 355 for saving Tapestry extended context to handle case360. The save slot reserved memory is inaccessible to virtual X86 310.Each save slot 355 has space 356 to hold a full Tapestry contextsnapshot. Each save slot 355 is assigned a number 357 foridentification, and a timestamp 358 indicating the time at which thecontents of the save slot were stored. Full/empty flag 359 indicateswhether the save slot contents are currently valid or not. In analternative embodiment, a timestamp 358 of zero indicates that the slotis unused.

Returning to FIG. 3 j, case 360 is handled as follows. A save slot 355is allocated 361 from among those currently free, and the slot is markedas in use 359. If no save slot is free, then the save slot with theoldest time stamp 358 is assumed to have been stranded, and is forciblyreclaimed for recycling. Recall that the save slots 355 are allocatedfrom non-paged storage, so that no page fault can result in thefollowing stores to the save slot. The entire Tapestry context,including the X86 context and the extended context, and the EIP (theexception instruction pointer, the address of the interruptedinstruction) is saved 362 into the context space 356 of allocated saveslot 355. The two low-order bits of the EIP (the address at which theX86 IP was interrupted) are overwritten 363 with the value “01,” as asignal to X86-to-Tapestry transition handler 320, 370. The EIP isotherwise left intact, so that execution will resume at the interruptedpoint. (Recall that case 360 is only entered when the machine wasexecuting native Tapestry code. Thus, the two low-order bits of the EIPwill arrive at the beginning of handler 350 with the value “00,” and noinformation is lost by overwriting them.) The current 64-bit timestampis loaded 364 into the EBX:ECX register pair (the low order halves ofregisters R49 and R51, see Table 1) and redundantly into ESI:EDI (thelow order halves of registers R54-R55) and the timestamp member (358 ofFIG. 3 k) of save slot 355. The 32-bit save slot number 357 of theallocated save slot 355 is loaded 365 into the X86 EAX register (the loworder half of register R48) and redundantly in EDX (the low order halfof register R50). Now that all of the Tapestry extended context isstored in the save slot 355, interrupt handler 350 of Tapestry operatingsystem 312 now transfers control to the “deliver interrupt” entry point352 of X86 emulator 316. X86 operating system 306 is invoked to handlethe interrupt.

Interrupt delivery raises a pending interrupt for the virtual X86 310.The interrupt will be accepted by X86 emulator 316 when the X86interrupt accept priority is sufficiently high. X86 emulator 316completes delivery of the interrupt or exception to the X86 by emulatingthe X86 hardware response to an interrupt or exception: pushing anexception frame on the stack (including the interrupted X86 IP, withbits <1:0> as altered at step 363 stored in EPC), and vectoring controlto the appropriate X86 interrupt handler.

Execution now enters the X86 ISR (interrupt service routine), typicallyin X86 operating system 306 kernel, at the ISR vectored by theexception. The X86 ISR may be an off-the-shelf routine, completelyunmodified and conventional. A typical X86 ISR begins by saving the X86context (the portion not already in the exception frame—typically theprocess' registers, the thread ID, and the like) on the stack. The ISRtypically diagnoses the interrupting condition, services it, anddismisses the interrupt. The ISR has full access to the X86 context. X86operating system 306 will not examine or rely on the contents of the X86processor context; the context will be treated as a “black box” to besaved and resumed as a whole. As part of servicing the interrupt, theinterrupted thread is either terminated, put to sleep, or chosen to beresumed. In any case, the ISR chooses a thread to resume, and restoresthe X86 context of that thread. The ISR typically returns control to theselected thread either via an X86 IRET instruction or an X86 JUMP. Ineither case, the address at which the thread is to be resumed is theaddress previously pushed in an X86 exception frame when theto-be-resumed thread was interrupted. The thread resumed by X86operating system 306 may be either interrupted thread 304 or another X86thread 302.

F. Resuming Tapestry Execution from the X86 Operating System

Referring again to FIG. 3 h, X86 operating system 306 eventually resumesinterrupted thread 304, after a case 360 interrupt, at the point ofinterruption. X86 operating system 306 assumes that the thread is codedin X86 instructions. The first instruction fetch will be from a Tapestrypage (recall that execution enters case 360 only when interrupted thread304 was executing Tapestry native code). This will cause anX86-to-Tapestry transition exception, which will vector toX86-to-Tapestry transition handler 320. Because the low-order two bitsof the PC were set (step 363 of FIG. 3 j) to “01,” control dispatches321 to case “01” 370.

In step 371, the save slot numbers in the X86 EAX and EDX registers arecross-checked (recall that the save slot number was stored in theseregisters by step 365 of FIG. 3 j), and the timestamp stored 362 inEBX:ECX is cross-checked with the timestamp stored in ESI:EDI. If eitherof these cross-checks 371 fails, indicating that the contents of theregisters was corrupted, an error recovery routine is invoked 372. Thiserror routine may simply kill the corrupted thread, or it may bring thewhole TAXi system down, at the implementer's option. If the time stampspass validation, the timestamp from the EBX:ECX register pair issquirreled away 373 in a 64-bit exception handler temporary registerthat will not be overwritten during restoration of the full nativecontext. The contents of register EAX is used as a save slot number tolocate 374 the save slot 355 in which the Tapestry context is stored362. The entire Tapestry native context is restored 375 from the locatedsave slot 355, including restoration of the values of all X86 registers.Restore 375 also restores the two low-order bits EPC<1:0> to Zero. Thesave slot's timestamp 358 is cross-checked 376 against the timestampsquirreled away 373 in the temporary register. If a mismatch of the twotimestamps indicates that the save slot was corrupted, then an errorrecovery routine is invoked 377. The save slot is now empty, and ismarked 378 as free, either by clearing full/empty flag 359 or by settingits timestamp 358 to zero. Execution is resumed at the EPC.EIP value byRFE instruction 338, in the Tapestry code at the point following theinterrupt.

Referring again to FIG. 3 k, in an alternative embodiment, save slots355 are maintained in a variation of a queue: hopefully-empty save slotsto be filled are always allocated from the head 379 a of the queue, fullsave slots to be emptied may be unlinked from the middle of the queue,and save slots may be entered into the queue at either the head 379 a ortail 379 b, as described infra. A double-linked list of queue entries ismaintained by links 379 c. At step 361, a save slot is allocated fromthe head 379 a of the allocation queue. After step 365, the filled saveslot 355 is enqueued at tail 379 b of the save slot queue. At step 377,the emptied save slot 355 is queued at the head 379 a of the queue.

This alternative head-and-tail queuing protocol 361, 379 a, 379 b, 379c, 375 for save slots 355 has the following effects. The queue remainssorted into two partitions. The portion toward head 379 a accumulatesall save slots 355 known to be free. The portion toward the tail 379 bholds all slots thought to be busy, in least-recently-used order. Overtime, all stale slots (those thought to be busy but whose threads havedisappeared) will accumulate at the boundary between the two partitions,because any time a slot with a timestamp older than that of a stale slotis resumed, the emptied slot is removed from the busy tail partition ismoved to the free head partition. Normally, allocations will occur byintensively recycling the most recently freed slots at the head of thefree partition while truly busy slots will cluster at the tail of thebusy partition. When all known-free save slots 355 are exhausted and anapparently-busy save slot 355 is overwritten, the busy save slots 355will be selected in least recently used to most recently busied.

In an alternative embodiment, a native Tapestry process would be allowedto call into an X86 library 308. Exceptions raised in the X86 code wouldbe serviced by the Tapestry operating system 312, filtered out inhandler 350 of FIG. 3 j before the decision point reaches the beginningof the code shown in FIG. 3 j.

G. An Example

Referring to FIG. 3 m in conjunction with FIGS. 3 a, 3 g, 3 h, 3 i, 3 land 3 n, consider an example of a call by an X86 caller thread 304 to aTapestry callee library 308, an interrupt 388 in the library that isserviced by X86 operating system 306, a context switch to another X86thread 302 and a resumption of Tapestry callee 308, and a return to theX86 caller 304.

Tapestry library 308 is mapped 382 into a 32-bit flat address space 380.From the point of view of X86 caller thread 304, this is the process'address space. From the point of view of the Tapestry machine andoperating system 312, the 32-bit address space is simply an addressspace that is mapped through page tables (170 of FIGS. 1 a and 1 d), andwhose contents and meaning are left entirely to the management of X86operating system 306.

Initially, thread 304 is executing on virtual X86 310. Thread 304executes an X86 CALL instruction 383, seeking a library service. Thebinary code for thread 304 is conventional X86 code, not speciallycompiled for use in a Tapestry system. CALL instruction 383 transferscontrol (arrow {circle around (1)}) to the entry point of library 308.This is the GENERAL entry point (317 of FIG. 3 g) for a Tapestry-binaryreplacement for the library. Fetching the first instruction from theentry preamble 317, 319 for Tapestry native library routine 308, inducesa change from X86 ISA to Tapestry ISA. Processor 100 takes a transitionexception 384, and vectors (arrow {circle around (2)}) toX86-to-Tapestry transition handler (320 of FIG. 3 h). Because allTapestry instructions are aligned to a 0 mod 4 boundary, the twolow-order bits of the interrupt address are “00.” Accordingly,transition handler 320 dispatches 321 to the “00” case 322 to establishthe preconditions for execution in the Tapestry context (32-byte alignedstack, etc.). At the end of transition handler 320, execution resumes338 (arrow {circle around (3)}) at GENERAL entry point 317. GENERALentry point 317 begins by executing the X86 preamble (319 of FIG. 3 g),which copies the parameter list into the P0-P15 parameter registers, andexecution of the body of Tapestry library routine 308 begins.

Assume that Tapestry library routine 308 runs to completion without aninterrupt or call back to X86 code.

When Tapestry library routine 308 completes 385, routine 308 loads avalue describing the form of its return value into XD register (R15 ofTable 1). This value will indicate a return value in RV0, RVFP, or amemory location, as appropriate. Routine 308 concludes with a TapestryJALR instruction to return (arrow {circle around (4)}). As the firstinstruction is fetched from X86 caller thread 304, a transition 386 fromTapestry ISA to X86 ISA is recognized, and control vectors (arrow{circle around (5)}) to Tapestry-to-X86 transition handler (340 of FIG.3 i). Transition handler dispatches 341 on the value of XD<03:00> to oneof the return cases 342, which copies the return value from its Tapestryhome to its home under the X86 calling convention. When transitionhandler 340 completes, it returns control (RFE instruction 349 of FIG. 3i, arrow {circle around (6)} of FIGS. 3 a, 3 l and 3 m) to theinstruction in thread 304 following the initial CALL 383.

Referring now to FIG. 3 n in conjunction with FIGS. 3 a, 3 h, 3 j and 3l, assume that an external asynchronous interrupt 388 occurred midwaythrough the execution of Tapestry library routine 308. To establish theexample, assume that the interrupt is a disk-completion interrupt thatunblocks a second, higher-priority X86 thread 302. The interrupt vectors(arrow {circle around (7)}) to the interrupt/exception handler (350 ofFIG. 3 j) of Tapestry operating system 312. After disqualifying cases351, 353, 354, interrupt handler 350 selects case 360. The fullprocessor context is saved 362 in a save slot 355, the two low-orderbits EIP<01:00> are overwritten 363 with “01,” as described in Table 3,and the save slot number and timestamp information are loaded 364, 365into the X86 registers. The interrupt handler 360 delivers the interrupt(369 of FIG. 3 j) to the interrupt entry point 352 of X86 emulator 316(arrow {circle around (8)}). X86 emulator 316 passes control to X86operating system 306 (arrow {circle around (9)}). X86 operating system306 services the interrupt in the conventional manner. However, thecontext that X86 operating system 306 saves for thread 304 is thecollection of timestamp and save slot number information with the EIPintact except for its two low-order bits, cobbled up by step 363 ofTapestry exception handler 360 to conform to Table 3. As assumed earlierin this paragraph, X86 operating system 306 selects thread 302 to beresumed (arrow {circle around (10)}).

After X86 thread 302 has executed for a time, it eventually cedescontrol (arrow {circle around (11)}) back to X86 operating system 306,for instance because its time slice expires, it issues a new diskrequest, or the like. Assume that the X86 operating system's schedulernow selects thread 304 to be resumed. The context restored by X86operating system 306 is the timestamp and save slot number “context”cobbled up by exception handler 360. The EIP of this restored contextpoints to the instruction following the interrupted 388 instruction,with “01” in the two low-order bits. X86 operating system 306 executesan IRET instruction to resume execution at this restored context (arrow{circle around (12)}). This instruction fetch will recognize thetransition 389 from the X86 ISA of X86 operating system 306 to theTapestry ISA of Tapestry library 308, and will vector (arrow {circlearound (13)}) to X86-to-Tapestry transition handler 320 (FIG. 3 h).Transition handler 320 dispatches 321 on the two low-order bits of theEIP address to case 370. The code of case 370 looks in the X86 registersto find the address of the save slot 355 corresponding to the process tobe resumed. The content of the X86 registers and found save slot 355 arevalidated 371, 374, 376 by comparing the redundantly-stored timestampsand save slot numbers against each other. The content of save slot 355restores 375 the full Tapestry processor context. Transition handler 320resumes 378 execution of the Tapestry library routine 308 (arrow {circlearound (14)}) at the point of the original external interrupt 388.

Referring to FIG. 3 o in conjunction with FIGS. 3 a, 3 h, 3 j and 3 l,consider the case of a call from a Tapestry native caller 391 to an X86callee 392. (Recall from the discussion of FIG. 3 b that neither isspecially coded to be tailored to this scenario—the X86 callee wasgenerated by a conventional X86 compiler, and the Tapestry caller 391 iscoded to work equally well whether the callee is an X86 callee 392 or aTapestry callee.) Caller 391 sets 393 the value of the XD register (R15of Table 1) to a value that describes the layout in the Tapestryregisters (R32-R47 of Table 1) of its argument list. Then caller 391issues a JALR instruction 394 to call to callee 392. On arrival at thefirst instruction of callee 392, processor 100 recognizes aTapestry-to-X86 transition 395. Execution vectors (arrow {circle around(15)}) to Tapestry-to-X86 exception handler (340 of FIG. 3 i). The fourlow-order bits XD<3:0> were set by instruction 393 to contain a basicclassification of the XD descriptor, and execution is dispatched 341according to those four bits, typically to code segment 343-345 or tosegment 343, 346, 347. The dispatched-to code segment moves 347 theactual parameters from their Tapestry homes to their X86 homes, asdirected by the remainder of the XD register. Handler 340 overwrites345, 346 the two low-order bits of the return PC, LR<1:0> with either“10” or “11” to indicate the location in which caller 391 expects thereturn result, as described in Table 3. Handler 340 returns (arrow{circle around (16)}) to the first instruction of X86 callee 392, whichexecutes in the conventional manner. When callee 392 completes, an X86RET instruction returns control to caller 391 (arrow {circle around(17)}). The first instruction fetch from caller 391 will trigger atransition exception 396. The exception vectors (arrow {circle around(18)}) control to X86-to-Tapestry handler 320. Based on the twolow-order bits of LR, handler 320 reformats and/or repositions 330, 333,334 the function return value. The handler completes 336, 338, andreturns control (arrow {circle around (19)}) to the instruction incaller 391 following the original call 394.

Referring again to FIGS. 3 a and 3 l, the complexity is confined tocases of cross-ISA calls. Complexity in handling cross-ISA calls isacceptable because transparent cross-ISA calling is not previously knownin the art. In a case where caller, callee, and operating system allshare a common ISA, no transition exceptions occur. For instance, when aTapestry process 314 calls (arrow {circle around (20)})) the sameTapestry library routine 308, routine 308 enters through NATIVE entrypoint 318, or takes the Tapestry short path through GENERAL entry point317. (Note that routine 308 will have to be separately mapped 397 intothe address space of Tapestry process 314—recall that Tapestry process314 is under the management of Tapestry OS 312, while the address space380 of an X86 process is entirely managed by X86 operating system 306,entirely outside the ken of Tapestry operating system 312.) If the sameexternal interrupt 388 occurs (arrow {circle around (21)}), theinterrupt can be handled in Tapestry operating system 312 (outside thecode of FIG. 3 j), and control will directly resume (arrow {circlearound (22)}) at the instruction following the interrupt, withouttracing through the succession of handlers. When Tapestry libraryroutine 308 completes, control will return to the caller (arrow {circlearound (23)}) in the conventional manner. The only overhead is a singleinstruction 393, setting the value of XD in case the callee is in X86code.

H. Alternative Embodiments

In an alternative embodiment, a “restore target page” of memory isreserved in the operating system region of the X86 address space. InPFAT 172, ISA bit 180 for the restore target page is set to indicatethat the instructions on the page are to be interpreted under theTapestry instruction set. This restore target page is made nonpageable.At step 363 of FIG. 3 j, the EPC.EIP value is replaced with an X86address pointing into the restore target page, typically with byteoffset bits of this replacement EPC.EIP storing the number of the saveslot. In an alternative embodiment, the EPC.EIP is set to point to therestore target page, and the save slot number is stored in one of theX86 registers, for instance EAX. In either case, when X86 operatingsystem 306 resumes the thread, the first instruction fetch will triggeran X86-to-Tapestry transition exception, before the first actualinstruction from the restore target page is actually executed, becausethe restore target page has the Tapestry ISA bit set in its PFAT andI-TLB entries. X86-to-Tapestry transition handler 320 begins by testingthe address of the fetched instruction. An address on the restore targetpage signals that there is extended context to restore. The save slotnumber is extracted from the instruction address (recall that the saveslot number was coded into the EPC or EAX on exception entry, both ofwhich will have been, restored by X86 operating system 306 in theprocess of resuming the thread). The processor context is restored fromthe save slot, including the EPC.EIP value at which the thread wasoriginally interrupted. In an alternative embodiment, only the extendedcontext (not including the X86 context) is restored from the save slot,so that any alterations to the X86 context effected by Tapestryoperating system 312 are left intact. X86-to-Tapestry transition handler320 executes an RFE 338 to resume execution in the interrupted Tapestrycode.

Note that no instruction from the restore target page is actuallyexecuted; the address is simply a flag to X86-to-Tapestry transitionhandler 320. All that is required is that the address of the restoretarget page be representable in the X86 address space, so that theaddress can pass through X86 operating system 306 and its threadscheduler. In alternative embodiments, a fetch from the restore targetpage could raise another exception—an unaligned instruction fault, or anaccess protection fault. It is desirable, however, that the fault raisedbe one not defined in the X86 architecture, so that no user program canregister a handler for the fault.

In this alternative embodiment, the “01” case 370 of X86-to-Tapestrytransition handler 320 may also save the X86 thread's privilege mode,and reset the privilege level to user, even if the X86 caller wasrunning in privilege ring zero. The privilege mode is changed to protectsystem integrity, to disallow a Tapestry Trojan horse from subvertingX86 security checks.

In an alternative embodiment, the correspondence between save slots andX86 threads is maintained by using thread-ID calls into X86 operatingsystem 306. Each save slot 355 may be associated with a Windows threadnumber for the duration of that thread. A garbage collector may be usedto recognize save slots that were filled a long time ago and are nowapparently abandoned. The garbage collector reclaims save slots after asystem-tunable time period, or on a least-recently-filled basis, on theassumption that the thread was terminated by X86 operating system 306.

In another alternative embodiment, when Tapestry takes an exceptionwhile in X86 converter mode, the extended context is snapshotted aswell. If the operating system uses the X86 TSS (Task-State Segment) toimplement multi-tasking, then the PSW portion of the extended context(ISA 194, XP/calling convention 196, and semantic class 206, see sectionIV, infra) can be snapshotted into unused parts of the X86 TSS.Otherwise the amount of data involved, five bits (ISA bit 194,XP/calling convention bit 196, and semantic context 206), is smallenough that it can be squirreled away within the ten unused bits at thetop of EFLAGS. In some embodiments, it may be possible to push theextended context as an additional word pushed onto the exception stackin X86 space.

In another alternative embodiment, the extended context can be stored inmemory in Tapestry space, where it is inaccessible to the X86. A hashtable (or an equivalent associative software structure) links aparticular X86 exception frame to its associated snapshot of theextended Tapestry context, so that on exception exit or taskrescheduling, when the processor reloads a particular X86 context intothe EPC (error PC and program status word), in turn to be reloaded intothe PSW by an RFE instruction (or when an X86 POPF instruction isemulated), the extended Tapestry context can be located and placed inthe EPC as well.

IV. An Alternative Method for Managing Transitions from One ISA to theOther

A. Indicating the Calling Convention (CC) for Program Text

Sections IV.A and IV.B together describe an alternative mechanism usedto determine the conventions under which data are passed to or from asubprogram, and thus the locations in which subprogram arguments or afunction return value are stored before a control-transfer event, sothat an exception handler can move the data to the locations expected bythe code to be executed after the control-flow event.

In the alternative Tapestry emulation of the X86 CISC architecture, anyparticular extent of native code observes one of two different callingconventions (see section III.B, supra): one RISC register-based callingconvention for calls from native Tapestry code to native Tapestry code,and another quasi-CISC memory-based convention that parallels theemulated CISC calling convention, for use when it is believed likelythat the call will most frequently cross from one ISA to the other. Thefeatures described in sections IV.A and IV.B provide sufficientinformation about the machine context so that a transition from one ISAto the other can be seamlessly effected.

Referring again to FIG. 3 a, programs coded in the native Tapestryinstruction set, when calling a subprogram, may use either aregister-based RISC calling convention, or a memory-based callingconvention that parallels the X86 convention. In X86 converter mode, allsubprogram calls use the memory-stack-based calling convention. Ineither mode, control may be transferred by an internal jump in which thedata passes from source to destination simply by its location in certainmemory or register locations.

Program text regions 176 are annotated with a bit 200 that indicates thecalling convention used by the code in the region. When execution flowsfrom a source observing one calling convention to a destinationobserving another, the difference in calling convention bits 200 willtrigger a transition exception. The transition exception handler copiesthe subprogram arguments from the well-known location established by thesource convention to the well-known location expected by thedestination. This allows caller and callee subprograms to be compiledwith no reliance on the calling convention used by the other, and allowsfor more seamless system operation in an environment of binaries andlibraries of inhomogeneous ISA.

Referring to FIGS. 1 d and 2 a, calling convention bit 200 is stored inPFAT entries 174 and I-TLB 116 in a manner analogous to ISA bit 180, 182with a record of the calling convention of the previous instructionavailable in PSW 190 calling convention bit 196, as discussed in sectionII, supra; the alternative embodiments discussed there are equallyapplicable here. (Because the calling convention property 200 is onlymeaningful for pages of Tapestry code, and the XP write-protect property184, 186 (discussed in section I.F, supra) is only used for pages of X86code, the two properties for a given page can encoded in a singlephysical bit, overlaying the XP write-protect bits 184, 186—this singlebit has different meanings depending on the PSW.ISA bit 194.)

Referring to FIGS. 2 b and 2 c, when execution crosses (column 204) froma region of one calling convention 200 to a region of another callingconvention 200, the machine takes an exception. Based on the directionof the transition (Tapestry-to-X86 or X86-to-Tapestry) and aclassification (as shown in Table 4 and discussed in IV.B, infra) of theinstruction that provoked the transition, the exception is vectored toan exception handler that corresponds to the direction andclassification. The eight calling convention transition exceptionvectors are shown in the eight rows 242-256 of FIG. 2 c. (The eightexception vectors for calling convention transitions are distinct fromthe two exception vectors for ISA transitions discussed in section II,supra.) The exception vectoring is specific enough that arrival at aspecific handler largely determines a mapping from the old machinecontext to a machine context that will satisfy the preconditions forexecution in the new environment. The exception handler implements thismapping by copying data from one location to another. The exceptionhandler operates during an exception interposed between the sourceinstruction and the destination instructions transforming the machinecontext from that produced by the last instruction of the source (forinstance, the argument passing area established before a CALL) to thecontext expected by the first instruction of the destination (theexpectations of the code that will begin to use the arguments).

Further information used to process the transition exception, and thehandling of particular exception cases, is described in section IV.B,infra.

B. Recording Transfer of Control Semantics and Reconciling CallingConventions

Merely knowing the direction of a transition (from X86 callingconvention to Tapestry convention or vice versa) is insufficient todetermine the actions that must be taken on a transition exception whenthe data storage conventions disagree. This section describes a furthertechnique used to interpret the machine context, so that the appropriateaction can be taken on a transition exception. In overview, as eachcontrol-transfer instruction is executed, the intent or semantic classof the instruction is recorded in the SC (semantic class) field 206(PSW.SC) of PSW (the Program Status Word) 190. On a transitionexception, this information is used to vector to an exception handlerprogrammed to copy data from one location to another in order to effectthe transition from the old state to the new precondition.

TABLE 4 semantic ISA of class representative source value Meaninginstructions Tap 00 Call JAL, JALR Tap 01 Jump conditional jump, J, JALRTap 10 Return with no FP result JALR Tap 11 Return with FP result JALRX86 00 Call CALL X86 01 Jump JMP, Jcc X86 10 Return with no FP resultRET X86 11 Return with (possible) FP RET result

Referring to FIGS. 1 e and 2 c and to Table 4, the control-flowinstructions of both the Tapestry ISA and the X86 ISA are classifiedinto five semantic classes: JUMP, CALL, RETURN-NO-FP (return from asubprogram that does not return a double-precision floating-pointresult), RETURN-FP (return from a subprogram that definitely returns adouble-precision floating-point result, used only in the context ofreturning from a Tapestry native callee), and RETURN-MAYBE-FP (returnfrom a subprogram that may return or definitely returns either a 64-bitdouble-precision or 80-bit extended precision floating-point result,used only in the context of returning from an X86 callee). Because thereare four possible transfers for each ISA mode, two bits 206 (combinedwith PSW.ISA bit 194) are sufficient to identify the five statesenumerated.

Most of this semantic classification is static, by instruction opcode.Some instructions, e.g., the X86 Jump and CALL instructions, aresemantically unambiguous. For instance, an X86 RET cannot be mistakenfor a CALL or an internal control flow JUMP. Thus, even though theTapestry system never examines the source code for the X86 binary, theX86 instruction contains sufficient information in its opcode todetermine the semantic class of the instruction.

Referring to Table 4, some of the semantic classification is encodedinto instructions by the compiler. For instance, the Tapestry JALRinstruction (jump indirect to the location specified by theinstruction's source register, and store the link IP (instructionpointer) in the destination register), may serve any of several roles,for instance as a return from subprogram (the link IP is stored into theread-zero register), a FORTRAN assigned go-to within a single routine,or a subprogram call. To resolve the ambiguity of a JALR instruction,bits that are unused in the execution of the instruction are filled inby the compiler with one of the semantic class codes, and that code iscopied as an immediate from the instruction to PSW.SC 206 when theinstruction is executed. In the case of Tapestry native binariescompiled from source code, this immediate field of the JALR instructionis filled in with the aid of semantic information gleaned either fromthe source code of the program being compiled. In the case of a binarytranslated from X86 to Tapestry, the semantic class of the X86instruction is used to determine the semantic class of the correspondingTapestry instruction. Thus, the Tapestry compiler analyzes the programto distinguish a JALR for a branch to a varying address (for instance aFORTRAN assigned or computed go-to, or a CASE branch through a jumptable) from a JALR for a function return (further distinguishing thefloating-point from no-floating-point case) from a JALR for a subprogramcall, and explicitly fills in the two-bit semantic class code in theJALR instruction.

Some of the semantic classification is performed by execution timeanalysis of the machine context. X86 RET (return from subprogram)instructions are classified into two semantic context classes,RETURN-NO-FP (return from subprogram, definitely not returning afloating-point function result) and RETURN-MAYBE-FP (return, possibly ordefinitely returning a floating-point function result). The X86 callingconvention specifies that a floating-point function result is returnedat the top of the floating-point stack, and integer function results arereturned in register EAX. The instruction opcode is the same in eithercase; converter 136 classifies RET instructions on-the-fly based on theX86 floating-point top-of-stack. If the top-of-stack points to afloating-point register marked empty, then the X86 calling conventionunambiguously assures that the RET cannot be returning a floating-pointvalue, and the semantic class is set to RETURN-NO-FP. If thetop-of-stack register points to a full location, there may nonethelessbe an integer return value; the semantic context is set toRETURN-MAYBE-FP to indicate this ambiguity.

On an exception, PSW 190 (including ISA bit 194, calling convention bit196, and SC field 206) is snapshotted into the exception PSW, a controlregister of the machine. The PSW bits in the exception PSW are availablefor examination and modification by the exception handler. When theexception handler completes, the RFE (return from exception) instructionrestores the snapshotted exception PSW into the machine PSW 190, andmachine execution resumes. Thus, PSW.SC 206 is preserved acrossexceptions, even though it is updated during execution of the exceptionhandler (unless the exception handler deliberately modifies it bymodifying the exception PSW).

FIGS. 2 b and 2 c show how calling convention transitions are vectoredto the exception handlers. On a calling convention transition exception,five data are used to vector to the appropriate handler and determinethe action to be taken by the handler: the old ISA 180, 182, the new ISA180, 182, the old calling convention 196, the new calling convention196, and PSW.SC 206. In FIG. 2 b, the first column 204 shows the natureof the transition based on the first four, the transition of the ISA andCC bits. For instance, the third line 216 discusses a transition fromnative Tapestry ISA using native Tapestry register-based callingconventions (represented as the value “00” of the ISA and CC bits) toX86 code, which necessarily uses the X86 calling convention (representedas the value “1x,” “1” for the X86 ISA, and “x” for “don't care” valueof the CC bit). Table 4 shows that several different situations mayvector to the same exception handler. Note, for instance, that lines 214and 216 vector to the same group of four handlers, and lines 218 and 224vector to the same group of handlers. These correspondences arisebecause the memory manipulation required to convert from native Tapestrycalling convention to X86 calling convention, or vice versa, is largelythe same, whether the X86 convention is observed by native Tapestryinstructions or X86 instructions.

FIG. 2 c shows how the machine vectors to the proper exception handlerbased on semantic class. For instance, lines 242, 244, 246, and 248break out the four possible handlers for the 00=>01 and 00=>1x (nativeTapestry code using native calling conventions, to X86 code using X86conventions) ISA and CC transitions, based on the four possible semanticclasses of control-flow instruction. Lines 250, 252, 254, and 256 breakout the four possible handlers for the 01=>00 and 1x=>00 transitions,based on the four semantic classes of instruction that can cause thistransition.

Referring to FIG. 2 b, when crossing from one subprogram to another, ifthe source and destination agree on the convention used for passingarguments, either because they agree on ISA and calling convention (rows212, 220, 228, 230), or agree on calling convention even thoughdisagreeing on ISA (rows 222, 226), or because the data pass simply byvirtue of being stored in the same storage location in the source anddestination execution environments (rows 244, 252), then no interventionis required. For instance, when crossing from the X86 ISA using the X86calling convention to the Tapestry native ISA using the X86 convention,or vice-versa, data passes from one environment to the other, withoutactually moving from one hardware element to another, using the fixedmapping between X86 virtual resources and Tapestry physical resourcesusing the fixed mapping shown in Table 1 and discussed in section I.B,supra.

For instance, as shown in row 222, if a caller in Tapestry native code,using the memory based quasi-X86 calling convention, calls a routine inX86 code (or vice-versa, row 226), no arguments need be moved; only theinstruction decode mode need be changed.

On the other hand, if the calling conventions 200 disagree, and thearguments are being passed under one calling convention and receivedunder another, the calling convention exception handler intervenes tomove the argument data from the well-known locations used by the sourceconvention to the well-known locations expected by the destinationconvention. For instance, a subprogram CALL from an X86 caller to acallee in native Tapestry code that uses the native Tapestry callingconvention (rows 224, 250), or equivalently, from Tapestry code usingX86 conventions to native Tapestry using the native convention (rows218, 250), must have its arguments moved from the locations specified bythe memory stack-based caller convention to the locations specified bythe register-based callee convention.

Rows 214, 242 of FIGS. 2 b and 2 c show the case of a subprogram callwhere the caller is in Tapestry native code using the register-basednative calling convention, and the callee is in Tapestry native code butuses the quasi-X86 calling convention. (Similarly, as shown in rows 216,if the caller is in Tapestry native code using the register-based nativecalling convention, and the callee is coded in the X86 ISA, then thesame exception handler 242 is invoked, and it does the same work.) Theexception handler will push the subprogram arguments from their registerpositions in which arguments are passed under the native convention,into their memory stack positions as expected under the X86 callingconvention. If the arguments are of varying size, the X86 stack layoutof the argument buffer may be rather complex, and the mapping from thearguments in Tapestry registers to that argument buffer will becorrespondingly complex. The argument copying is specified by adescriptor, an argument generated by the compiler for annotation of thecaller site. This is particularly important for “varargs” routines.Because the native caller was generated by the Tapestry compiler, thecompiler is able to produce a descriptor that fully describes the datacopying to be performed by the transition exception. The descriptor isanalogous to the argument descriptors generated by compilers for use bydebuggers. The data will then be in the locations expected by thecallee, and execution can resume in the destination ISA mode.

When an X86 caller (or a Tapestry caller using the quasi-X86 callingconvention), the data of the argument block established by the callerare copied into the locations expected by the Tapestry callee. Forinstance, the linkage return address is copied from the top of stack tor6 (the Tapestry linkage register, given the alias name of LR for thispurpose). The next few bytes of the stack are copied into Tapestryregisters, for quick access. A call descriptor (a datum that describesthe format of the call arguments) is manufactured in register r51 (aliasCD), set to indicate that the arguments are passed under the X86convention. A null return value descriptor is manufactured on the stack;the return descriptor will be modified to specify the format of thereturn value, once that information is known.

When returning from a callee function, the calling convention 200 of thecaller and callee and the semantic class 206 of the return instructiondetermine the actions needed to put the function return value in thecorrect location expected by the callee. As shown in Table 1, the X86calling convention returns double-precision floating-point functionreturn values in the floating-point register indicated by thetop-of-floating-point-stack. The X86 calling convention returns otherscalars of 32 bits or less in register EAX, results of 33 to 64 bits inthe EAX:EDX register pair, and function return values of 65 bits orgreater are returned in a memory location pointed to by an argumentprepended to the caller's argument list. The native Tapestry callingconvention returns double-precision floating-point values in r31 (forthis purpose, given the alias name of RVDP), other return values of 256bits or less in registers r48, r49, r50, and r51 (given the alias namesof RV0, RV1, RV2, and RV3), and larger return values in a memorylocation pointed to by r31 (for this purpose, given the alias name ofRVA).

The Tapestry calling convention, and the mapping between Tapestry andX86 resources, are co-designed, at least in part, to maximize commonuses, thereby to reduce the amount of data copying required on a callingconvention transition. Thus, the two registers used to return scalarfunction return values—r48 (RV0) in Tapestry, EAX in X86—are mapped toeach other.

When returning from a native-convention callee to an X86 or aTapestry-using-X86-convention caller, the semantic class of the returnis unambiguously known (because whether the function returns afloating-point value or not was encoded in the semantic class bits ofthe JALR instruction by the compiler), and the semantic classdistinguishes the two actions to take in the two cases that may arise,as discussed in the next two paragraphs.

When a native-convention function returns a double-precision (64-bit)floating-point value to an X86-convention caller (the RETURN-FP case ofrow 248), the function return value is inflated from an IEEE-754 64-bitrepresentation in r31 (RVDP, the register in which Tapestry returnsdouble-precision function results) to an 80-bit extended precisionrepresentation in the register pair to which the X86 FP top-of-stackcurrently points (usually r32-r33, the Tapestry register pair mapped toF0 of the X86). The top-of-floating-point stack register is marked full,and all other floating-point registers are marked empty. (Tapestry has afloating-point status register that subsumes the function of the X86FPCW (floating-point control word), FPSW (floating-point status word),and FPTW (floating-point tag word), and the registers are marked full orempty in the tag bits of this status register.) On a return from anon-floating-point Tapestry native callee function to an X86-conventioncaller (the RETURN-NO-FP case of row 248) to an X86-convention caller,the function return value is left alone in r48, because this singleregister is both the register in which the Tapestry function computedits result, and the register to which the X86 register EAX (thefunction-result return register) is mapped. The entire floating-pointstack is marked empty.

If the native callee is returning a value larger than 64 bits to anX86-convention caller, a return descriptor stored on the stack indicateswhere the return value is stored (typically in registers r48 (RV0), r49(RV1), r50 (RV2), and r51 (RV3), or in a memory location pointed to byr31 (RVA)); the return value is copied to the location specified underthe X86 convention (typically a memory location whose address is storedin the argument block on the stack).

When returning from an X86 callee to a Tapestry-using-X86-conventioncaller, no action is required, because the register mapping of Table 1implements the convention transformation.

When returning from an X86 callee to a native Tapestry caller, two casesare distinguished by the two semantic classes RETURN-MAYBE-FP andRETURN-NO-FP. For the RETURN-NO-FP case of rows 224 and 254, no actionis required, because the return value was computed into X86 registerEAX, which is mapped to r48, the Tapestry scalar return value register.For the RETURN-MAYBE-FP case, the exception handler conservativelyensures that any scalar result is left in r48, and also ensures that thevalue from the top of the floating-point stack is deflated from an80-bit extended-precision representation to a 64-bit double-precisionrepresentation in r31 (RVDP).

When executing translated native code, Tapestry will not execute a JALRsubprogram return unless the destination is also in native code. Becausethe semantic class codes on the present implementation only ambiguouslyresolve whether an X86 instruction does or does not return afloating-point result (RETURN-FP vs. RETURN-MAYBE-FP), and the nativesemantic class codes are unambiguous (RETURN-FP vs. RETURN-NO-FP),binary translator 124 does not translate a final X86 RET unless itsdestination is also translated.

An alternative embodiment may provide a third calling convention value,a “transition” value. The machine will not take an exception whencrossing to or from a transition page—the transition calling convention“matches” both the X86 calling convention and the Tapestry callingconvention. Typically, pages of transition calling convention will havea Tapestry ISA value. These transition pages hold “glue” code thatexplicitly performs the transition work. For instance, an X86 callerthat wants to call a Tapestry callee might first call a glue routine ona transition calling convention page. The glue routine copies argumentsfrom their X86 calling convention homes to their Tapestry homes, and mayperform other housekeeping. The glue routine then calls the Tapestrycallee. The Tapestry callee returns to the glue routine, where the glueroutine performs the return value copying and performs otherhousekeeping, and returns to its caller, the X86 caller.

One of ordinary skill will understand the argument copying thatimplements each of the cases of transition exception shown in FIGS. 2 band 2 c. One embodiment is shown in full detail in the microficheappendix of the '394, '443, and '194 parent applications, incorporatedherein by reference.

In an embodiment alternative to any of the broad designs laid out insections II, III, or IV, the computer may provide three or moreinstruction set architectures, and/or three or more calling conventions.Each architecture or convention is assigned a code number, representedin two or more bits. Whenever the architecture crosses from a region orpage with one code to a region or page with another, an appropriateadjustment is made to the hardware control, or an appropriate exceptionhandler is invoked, to adjust the data content of the computer, and/orto explicitly control the hardware execution mode.

V. Profiling to Determine Hot Spots for Translation

A. Overview of Profiling

Referring to FIGS. 1 a, 1 b and 4 a, profiler 400 monitors the executionof programs executing in X86 mode, and stores a stream of datarepresenting the profile of the execution. Because the X86 instructiontext is typically an off-the-shelf commercial binary, profiler 400operates without modifying the X86 binary, or recompiling source codeinto special-purpose, profileable X86 instruction text. The executionrules for profiler 400 are tailored so that the right information willbe captured at the right time. Hot spot detector 122 identifies hotspots in the programs based on the profile data. The data collected byprofiler 400 are sufficiently descriptive to allow the application ofeffective heuristics to determine the hot spots from the profile dataalone, without further reference to the instruction text. In particular,the profile information indicates every byte of X86 object code that wasfetched and executed, without leaving any non-sequential flow toinference. Further, the profile data are detailed enough, in combinationwith the X86 instruction text, to enable binary translation of anyprofiled range of X86 instruction text. The profile informationannotates the X86 instruction text sufficiently well to resolve allambiguity in the X86 object text, including ambiguity induced by data-or machine-context dependencies of the X86 instructions. Profiler 400operates without modifying the X86 binary, or recompiling source codeinto a special-purpose profileable X86 binary.

In its most-common mode of operation, profiler 400 awaits a two-parttrigger signal (516, 522 of FIG. 5 a) to start sampling events, and thenrecords every profileable event 416 in a dense sequence, including everyprofileable event that occurs, until it stops (for instance, onexhaustion of the buffer into which profile information is beingcollected), as opposed to a conventional profiler that records every nthevent, or records a single event every n microseconds. The profileinformation records both the source and destination addresses of mostcontrol flow transfers. Entries describing individual events arecollected into the machine's general register file, and then stored in ablock as a profile packet. This blocking of events reduces memory accesstraffic and exception overhead.

Referring again to FIGS. 1 a and 1 b, profiler 400 tracks events byphysical address, rather than by virtual address. Thus, a profileableevent 416 may be induced by “straight line” flow in virtual addressspace, when two successive instructions are separated by a physical pageboundary, or when a single instruction straddles a virtual pageboundary. (As is known in the art, two pages that are sequential in avirtual address space may be stored far from each other in physicalmemory.) By managing the X86 pages in the physical address space,Tapestry operates at the level of the X86 hardware being emulated. Thus,the interfaces between Tapestry and X86 operating system 306 may be aswell-defined and stable as the X86 architecture itself. This obviatesany need to emulate or account for any policies or features managed byX86 operating system 306. For instance, Tapestry can run any X86operating system (any version of Microsoft Windows, Microsoft NT, or IBMOS/2, or any other operating system) without the need to account fordifferent virtual memory policies, process or thread management, ormappings between logical and physical resources, and without any need tomodify X86 operating system 306. Second, if X86 operating system 306shares the same physical page among multiple X86 processes, even if atdifferent virtual pages, the page will be automatically shared. Therewill be a single page. Third, this has the advantage that pages freeddeleted from an address space, and then remapped before being reclaimedand allocated to another use,

Referring to FIG. 4 b, events are classified into a fairly fine taxonomyof about thirty classes. Events that may be recorded include jumps,subprogram CALL's and returns, interrupts, exceptions, traps into thekernel, changes to processor state that alters instructioninterpretation, and sequential flow that crosses a page boundary.Forward and backward jumps, conditional and unconditional jumps, andnear and far jumps are distinguished.

Referring to FIGS. 4 g and 4 h, profiler 400 has a number of featuresthat allow profiling to be precisely controlled, so that the overhead ofprofiling can be limited to only those execution modes for which profileanalysis is desired.

Referring to FIGS. 5 a and 5 b, as each X86 instruction is decoded bythe converter (136 of FIG. 1 c), a profile entry is built up in a 64-bitprocessor register 594. During execution of the instruction, register594 may be modified and overwritten, particularly if the instructiontraps into Tapestry operating system 312. At the completion of theinstruction, profiler 400 may choose to capture the contents of theprofile entry processor register into a general register.

Hot spot detector 122 recognizes addresses that frequently recur in aset of profile packets. Once a hot spot is recognized, the surroundingentries in the profile may indicate (by physical address) a region ofcode that is frequently executed in correlation with the recurringaddress, and the path through the physical pages. Hot spot detector 122conveys this information to TAXi translator 124, which in turntranslates the binary.

B. Profileable Events and Event Codes

Referring to FIG. 4 b, profiler 400 recognizes and records about thirtyclasses of events, listed in the table. Each class of event has a code402, which is a number between 0 and 31, represented as a five-bitnumber. The class of events is chosen to provide both the minimuminformation required to support the design, and additional informationthat is not strictly necessary but may provide additional hints thatallow hot spot detector 122 to achieve better results.

The upper half 410 of the table lists events that are (in oneembodiment) raised by software, and lower half 404 contains eventsraised by hardware. The lower half will be discussed first.

The lower half 404 of the table, the sixteen entries whose high-orderbit is One, are events induced by converter 136. As each X86 instructionis decoded and executed, the events enumerated in lower half 404 arerecognized. If profiler 400 is active when one of these events 404occurs, a profile entry is recorded in a general register. The events inthe lower half of the table fall into two classes: near transfers ofcontrol that are executed in converter 136, and sequential flows ofexecution across a physical page frame boundary.

Profiler 400 captures transfers of control, including IP-relativetransfers, subroutine calls and returns, jumps through pointers, andmany interrupt-induced transfers. Even though profiler 400 views themachine in its physical address space, the distinction between forwardand backwards jumps can be determined for PC-relative jumps by lookingat the sign bit of the PC-relative displacement in the X86 instruction.Once the branch is classified, the classification is encoded in eventcode 402 stored in the profile entry for the branch. There are eventcodes 402 to separately classify forward conditional branches, backwardconditional branches, three separate classes of conditional jumppredicates, etc., as shown by event codes 1.0000, 1.0001, 1.0010,1.0011, 1.0100, 1.0101, and 1.0111.

Event code 1.1100 is discussed in section VIII.B.

Event code 1.1110 406 indicates a simple sequential instruction withnothing of note. Event code 1.1111 408 denotes an instruction thateither ends in the very last byte of a physical page or straddles a pageboundary in virtual address space (and is likely separated into twodistant portions in the physical address space).

The upper half 410 of the table, the top sixteen entries whosehigh-order bit is Zero, are events that are handled in software emulator316, and recorded during execution of a Tapestry RFE (return fromexception) instruction at the completion of the emulation handler. RFEis the Tapestry instruction that returns from Tapestry operating system312 to a user program after a synchronous exception,(for instance a pagefault or NaN-producing floating-point exception), an asynchronousexternal interrupt, or a trap into emulator 316 for simulation of aparticularly complex X86 instruction that is not implemented in thehardware converter 136. Generally, the events in the upper half of thetable fall into four classes: (1) far control transfer instructionsexecuted in emulator 316, (2) instructions that update the x86 executioncontext (e.g. FRSTOR) executed in emulator 316, (3) delivery of x86internal, synchronous interrupts, and (4) delivery of x86 external,asynchronous interrupts. In general the upper-half event codes are knownonly to software.

Each RFE instruction includes a 4-bit immediate field (588 of FIG. 5 b)in which is stored the low-order four bits of the event code 402associated with the event that invokes the returned-from handler. Thefifth bit in an RFE event class is reconstructed (see section V.G,infra) as a Zero, even though the Zero is not explicitly stored. Whenthe RFE is executed, the event code from the RFE is copied intoTAXi_State.Event_Code_Latch (486, 487 of FIGS. 4 h and 5 b) and thetemporary processor register (594 of FIG. 5 b) that collects profileinformation (see section V.F, infra), overwriting the event codesupplied by converter 136. From register 594, the event code will becopied into a general register if a profile entry is to be collected.This mechanism allows software to signal profiler 400 hardware 510 thata profileable instruction has been executed in emulator 316, or that anotherwise non-profileable instruction executed in emulator 316 caused apage crossing and should be profiled for that reason. (RFE's without X86significance will set this field to zero, which will prevent thehardware from storing a profile entry—see the discussion of code 0.0000,infra)

The “profileable event” column (416 of FIG. 4 b) specifies whether anthe event code is to be included in a profile packet. Events that arenot profileable simply occur with no action being taken by profiler 400.The “initiate packet” column 418 specifies whether an event of thisevent code (402 of FIG. 4 b) is allowed to initiate collection of a newprofile packet, or whether this event class may only be recorded inentries after the first. “Initiate packet” 418 is discussed at length insections V.F and V.G, infra, in connection with Context_At_Point profileentries, FIG. 4 c, and the profiler state machine 510, FIG. 5 a. The“probeable event” column 610 and “probe event bit” column 612 will bediscussed in connection with Probing, section VI, infra. The “initiatepacket” 418, “profileable event” 416, and “probeable event” 610properties are computed by PLA (programmable logic array) 650, which isdiscussed in sections VI.C and VI.D, infra.

Discussion of event codes 0.0000, 0.0001, 0.0010 and 0.0011 is deferredfor a few paragraphs.

An event code of 0.0100 is simply stored over the current value ofTAXi_State.Event_Code_Latch (486, 487 of FIGS. 4 h and 5 b), withoutfurther effect of the current state of the machine. The effect of thisoverwrite is to clear the previously-stored event code, ensuring thatconverter 136 can restart without any effects that might be triggered bythe current content of TAXi_State.Event_Code_Latch 486, 487. Forinstance, if converter 136 takes a probe exception (see section VI,infra), and the first instruction of the translated TAXi code generatesan exception (e.g., a floating-point overflow) that should be handled byreturning control to converter 136 (rather than allowing execution toresume in the translated TAXi code), the exception handler will returnwith an RFE whose event code immediate field is 0.0100. This ensuresthat converter 136 will not restart with the event code pending inTAXi_State.Event_Code_Latch 486, 487 that triggered the probe exceptionin the first place.

Event code 0.0101 indicates an emulator completion of an instructionthat changes the execution context, for instance, the full/empty stateof the floating-point registers or floating-point top-of-stack. Thiswill force the recording of Context_At_Point profile entry (see 430 ofFIG. 4 c and section V.C, infra) to capture the state change.

Events of event code 0.0110, 0.0111, 0.1000, 0.1001 are control-transferinstructions that are conveniently implemented in emulation softwareinstead of hardware converter 134, 136 such as far call, far jump, farreturn, and X86 interrupt return. The event code taxonomy for these fartransfers does not differentiate forward and backward jumps, in contrastto the taxonomy of IP-relative near jumps (event codes 1.0000-1.0101).

An RFE with an event code of 0.1010 causes TAXi_Control.special_opcode474 (bits <50:44>) to be captured in the special opcode 434 field (bits<50:43> of FIG. 4 c) of a Context_At_Point profile entry (430 of FIG. 4c). This opens up a new seven-bit space of event codes that can bemanaged completely by software.

Event code 0.1011 is used to RFE from an exception handler, to force thecurrent profile packet to be aborted. The Tapestry hardware recognizesthe event code in the RFE immediate field and aborts the profile packetby clearing TAXi_State.Profile_Active (482 of FIGS. 4 h and 5 a). Forinstance, this event code might be used after a successful probe RFE'sto TAXi code and aborts any packet in progress. This is because the TAXicode represent a break in the sequential interval of a profile packet,and an attempt to continue the packet would render it ill-formed.Similarly, when X86 single-step mode is enabled, the RFE from emulator316 uses event code 0.1011 to abort a packet in progress. Profiling willresume at the next profile timer expiry.

Event codes 0.100, 0.101, 0.110, and 0.1111 provide two pairs of RFEevent codes associated with delivery of X86 exceptions from X86 emulator316. This allows software to group exceptions into different categoriesfor TAXi usage. By classifying interrupts into two groups, and furtherinto probeable and non-probeable events (see section VI, infra), thesefour event codes provide a control framework for software to build upon.This classification exploits the fact that the X86 funnels allexceptions, external interrupts, and traps through a single unified“interrupt” mechanism.

Event codes 0.0000, 0.0001, 0.0010, and 0.0011 412 operate somewhatdifferently from the other events in upper half 410, as shown by the“reuse event code” column 414. Events of these classes (that is, RFEinstructions with these four-bit codes in their event code immediatefield) do not update TAXi_State.Event_Code_Latch (486, 487 of FIG. 4 h)and related signals; the previously-latched event code is simply allowedto persist for the next X86 instruction. For example, event code 0.0000is for “transparent” exceptions, exceptions that do not get recorded inthe profile. As a specific example, the RFE's at the end of the handlersfor TLB miss exceptions, interrupt service routines for purely-Tapestryinterrupts, and other exceptions unrelated to the progress of an X86program have event code 0.0000 (four explicit Zeros in the immediatefield, and an assumed high-order Zero), which causes the hardware toresume execution at the interrupted location without storing a profileentry. These events are kept architecturally invisible to thecurrently-executing process and are not correlated to any hot spot inthat process, and thus recording an event would be specious.

Event code 0.0001 is used in the software X86 emulator 316. Very complexX86 CISC instructions that are not implemented in hardware converter 136are instead implemented as a trap into software, where the instructionis emulated. When X86 emulator 316 completes the instruction, it returnsusing an RFE with an event code of 0.0001 to indicate that “nothingspecial happened here,” and so no profile entry is collected (unless theemulated instruction straddled a page).

Another use of the “reuse event code” feature of column 414 isillustrated by considering the case of a complex instruction, aninstruction that is emulated in software, that does not affect anycontrol flow, for instance a compare string instruction. When such acomplex instruction is encountered, converter 136, non-event circuit578, and MUX 580 of FIG. 5 b in section V.F, infra, will have made apreliminary decode of the instruction, and supplied a preliminary eventcode (582, 592 of FIG. 5 b): either the default event code 1.1110 406 ora new page event code 1.1111 408, depending on whether the instructionstraddles a page break. (In some embodiments, converter 136 may inaddition supply the event codes for far control transfers, far CALL,code 0.1000; far JMP, code 0.1001; far RET, code 0.0110; IRET, code0.0111). This preliminary event code 582, 592 is latched intoTAXi_State.Event_Code_Latch 486, 487 as part of trapping into X86emulator 316. When X86 emulator 316 completes the complex instructionand RFE's back to converter 136, the RFE will have as its event codeimmediate field (588 of FIG. 5 b) the simple X86 instruction-completeevent code 0.0001. Because event code 0.0001 has “reuse event code”property 414, the event code from the RFE immediate field will simply bediscarded, leaving intact the preliminary event code 582, 592 inTAXi_State.Event_Code_Latch 486, 487. On return from the exception, anevent with the preliminary event code is then added to the profilepacket.

Event codes 0.0010 and 0.0011 are used in the RFE from the probeexception handler (see section VI, infra). If a probe fails, that classof probe is disabled. Because probing and profiling are mutuallyexclusive (see section VI.G, infra), when there is a probe exception,profiling is not active. Thus, these event codes are never stored in aprofile packet, but exist to control prober 600, as described in sectionVI.D, infra.

C. Storage Form for Profiled Events

Referring to FIGS. 4 a, 4 c, and 4 d, profile events are collected andstored in groups called packets 420. Each profile packet 420 holds aprogrammable number of entries, initially collected into registersR16-R31, and then stored to memory. In a typical use, there will besixteen entries per packet, beginning with a 64-bit time stamp, thenfourteen event entries 430, 440, and an ending time stamp. Each event isdescribed as a 64-bit entry, of one of two forms: a Context_At_Pointentry 430, or a Near_Edge entry 440. The first entry in the packet isalways a Context_At_Point entry 430, which gives a relatively completesnapshot of the processor context at the point that profiling begins, apoint conceptually between two X86 instructions. Subsequent entries maybe of either Context_At_Point or Near_Edge form. A Near_Edge entry 440describes an intra-segment (i.e., “near”) control transfer, giving thesource and destination of the transfer. At a Near_Edge entry 440, theremainder of the X86 processor context can be determined by starting atthe most-recent Context_At_Point entry 430 and inferring the processorcontext by interpreting the instructions that intervened between thatContext_At_Point and the Near_Edge transfer. Sufficient information ispresent in the profile so that the context can be inferred by binarytranslator 124 by reference only to the opcodes of those interveninginstructions, without requiring any knowledge of the actual dataconsumed or manipulated by those instructions. The rules for emitting aContext_At_Point entry 430 preserve this invariant: processor context isinferable from the combination of the profile and the opcodes of theintervening instructions, without reference to any data consumed ormanipulated by the instructions. If execution of an X86 instructiondepends on memory data or the processor context bits in a manner notrepresentable in a Near_Edge entry 440, then profiler 400 emits aContext_At_Point entry 430. Thus, Context_At_Point entries ensure thatthe TAXi binary translator 124 has sufficient information to resolveambiguity in the X86 instruction stream, in order to generate nativeTapestry code.

Referring to FIG. 4 c, a Context_At_Point entry 430 describes an X86instruction boundary context snapshot, a context in effect as executionof an X86 instruction is about to begin.

Bits <63:60> 431 of a Context_At_Point entry 430 are all Zero, todistinguish a Context_At_Point entry 430 from a Near_Edge entry 440. (Asnoted in the discussion of done length 441, bits <63:60> of FIG. 4 d,infra, in a Near_Edge 440 the first four bits record the length of aninstruction, and there are no zero-length instructions. Thus, a zerovalue in field 431 unambiguously indicates a Context_At_Point 430.)

Bits <59:51> 432, 433 and <42:32> 435 capture the processor mode contextof the X86 at the instruction boundary (before the start of theinstruction described in next_frame 438 and next byte 439, bits<27:00>). The bits of an X86 instruction do not completely specify theaction of the instruction; the X86 architecture defines a number ofstate bits that define the processor context and the operation ofinstructions. These bits determine operand size (whether a given wideform instruction acts on 16 bits or 32), stack size (whether a PUSH orPOP instruction updates 16 bits or 32 of the stack pointer), addresssize (whether addresses are 16 or 32 bits), whether the processor is inV86 mode, whether addressing is physical or virtual, the floating-pointstack pointer, and the full/empty state of floating-point registers. TheX86 scatters these bits around code and stack segment descriptors, theEFLAGS register, the floating-point status word, the floating-point tagword, and other places. The Tapestry machine stores these bits inanalogs of the X86 structures to actually control the machine; when aContext_At_Point entry 430 is captured, a snapshot of these bits arecaptured into bits <59:51> 432, 433 and <42:32> 435 of theContext_At_Point entry 430.

Bits <59:56> 432 indicate the current state of theoperand-size/address-size mode (encoded in the D bit of the X86 codesegment descriptor), and the stack address size (encoded in the B bit ofthe stack segment descriptor). Bit <59>, “c1s1,” indicates that the X86is in 32-bit-code/32-bit-stack mode. Bit <58>, “c1s0,” indicates thatthe X86 is in 32-bit-code/16-bit-stack mode. Bit <57>, “c0s1,” indicatesthat the X86 is in 16-bit-code/32-bit-stack mode. Bit <56>, “c0s0,”indicates that the X86 is in 16-bit-code/16-bit-stack mode. (The D and Bbits render the X86 instruction set ambiguous. For instance, a givennine-byte sequence of the instruction stream might be interpreted as asingle instruction on one execution, and three entirely differentinstructions on the next, depending on the values of the D and B bits.Very few architectures share this ambiguity.) Thus, whether or not toprofile any particular combination of the four possible combinations ofD and B modes can be individually controlled.

In field 433, bit <55>, “pnz,” indicates that the X86 is innon-ring-zero (unprivileged) mode. Bit <54>, “pez,” indicates that theX86 is in X86 ring-zero (privileged) mode. Bits <53>, <52>, and <51>,“v86,”“real,” and “smm,” indicate respectively, that the X86 is invirtual-8086, real, and system management execution modes, as indicatedby X86 system flag bits.

Bits <50:43>, special_opcode 434, are filled fromTAXi_Control.special_opcode 474 whenever a Context_At_Point entry isgenerated. These bits are especially relevant to event code 0.1010.

In field 435, bits <42:40> are the floating-point top-of-stack pointer.Bits <39:32> are the floating-point register full/empty bits.

Field event_code 436, bits <31:28>, contains an event code 402, the fourleast significant bits from the most recently executed RFE or converterevent code (from FIG. 4 b). The four bits of the Context_At_Pointevent_code 436 are the four low order bits of the event code 402 of FIG.4 b. The high-order bit is derived from these four by a method that willbe described in section V.G, infra. As will be described more fullythere, a Context_At_Point entry 430 can describe any of the sixteenevents from the upper half 410 of the table, or an event with the“initiate packet” property 418 from anywhere in the table of FIG. 4 b.

Bits <27:00> describe the next X86 instruction, the instruction about tobe executed at the time that the Context_At_Point context wassnapshotted. Field next_frame 438, bits <27:12>, give a physical pageframe number, and field next_byte 439, bits <11:00>, give a 12-bitoffset into the page.

Referring to FIG. 4 d, a Near_Edge entry 440 describes a completed X86intra-segment “near” control transfer instruction. Bits <63:60> 441 of aNear_Edge entry 440 describe the length of the transfer instruction. Thelength 441 value is between one and fifteen (the shortest X86instruction is one byte, and the longest is fifteen bytes). Because azero length cannot occur, these four bits 431 distinguish a Near_Edgeentry 440 from a Context_At_Point entry 430.

The instruction at the source end of the Near_Edge transfer is describedby a page frame number in which the instruction begins, a page framenumber in which the instruction ends, a byte offset into the page wherethe instruction begins, and an instruction length. The page frame numberfor the beginning of the instruction is not explicitly represented inthe Near_Edge entry 440, but rather is inherited as the next_frame value438, 448 from the immediately-preceding entry in the profile packet(recall that profile packet always start with a Context_At_Point entry430, and that a Near_Edge entry 440 is never the first entry). The pageframe in which the last byte of the instruction lies is represented infield done_frame 444, bits <59:44>. These two page frame numbers willdiffer if the instruction straddles a page boundary. The byte offsetinto the page where the instruction begins is represented in fielddone_byte 445, bits <43:32>. The length is recorded in field done_length441, bits <63:60>. Thus, the source instruction ends at the byte foundby summing (((done_byte 445+done_length 441)−1)mod 4096) (4096 becausethat is the size of an X86 page).

The destination of the Near_Edge transfer is described by next_frame 448and next_byte 449 fields in bits <27:00>, in the manner of thenext_frame 438 and next_byte 439 fields, bits <27:00>, described suprafor a Context_At_Point entry 430.

Field event_code 446, bits <31:28>, contains an event code, parallel tothe event code 436 of a Context_At_Point entry 430. The four bits of theNear_Edge event_code 446 are the four low order bits of the bottom halfof FIG. 4 b; a leading One is assumed. (Thus a Near_Edge entry 440 canonly describe one of the sixteen events in the lower half 404 of FIG. 4b.)

Thus, all physical pages are mentioned in successive profile entries intheir execution order. When execution crosses from one physical page toanother because of an explicit branch, the branch is indicated by aNear_Edge entry 440. When execution crosses from one physical page toanother because of sequential execution in virtual address space acrossa page boundary, a Near_Edge entry 440 will be generated either betweenthe instruction that ended at the end of the page and the instructionthat begins the next, or between the instruction that straddles the pagebreak and the first full instruction of the next page. Alternatively, ifcontrol enters a page without a Near_Edge event, a Context_At_Pointprofile entry 430 will describe the arrival at the page. Together, theserules ensure that sufficient information exists in the profile entriesthat the flow of execution can be retraced, and a hot spot detected,without reference to the binary text. Allowing the hot spot detector tooperate without examining the instruction text allows it to run withoutpolluting the cache. Further, the guarantee that all physical pages arementioned allows for profiling of the program as it exists in thephysical memory, even though the X86 executes the instructions from thevirtual address space. The guarantee ensures that control flow can betraced through the physical memory, without the need to examine theprogram text to infer adjacency relationships.

For a Near_Edge entry 440, the X86 processor context on arrival at thedestination instruction is inferable from fields 432, 433 (bits <59:51>)and 435. (bits 42:32>) of the nearest-preceding Context_At_Point entry430, by starting with the context 432, 433, 435 encoded in thatContext_At_Point 430, and tracing forward through the opcodes of theintervening instructions to capture any updates.

D. Profile Information Collected for a Specific Example Event—a PageStraddle

Referring to FIGS. 4 e and 4 f, consider two instances of instructionsthat straddle a page boundary. FIGS. 4 e and 4 f are drawn in virtualaddress space, though profiler 400 operates in physical address space.

In FIG. 4 e, consider instruction 450 that straddles a page boundary 451between pages 452 and 453, and is not a transfer-of-control instruction.The page-crossing is described by a Near_Edge entry 440, 454 with asequential event code, code 1.1110 (406 of FIG. 4 b). The instructionbegins in the page 452 identified in the next_frame bits (bits <27:12>)438, 448, 452 a of the immediately previous profile entry 455, whetherthat previous entry is a Context_At_Point 430 or a Near_Edge 440. Theinstruction begins at a byte offset indicated by done byte 445 (bits<43:32>) of current Near_Edge 454. The length of the instruction isindicated in done length 441 (bits <63:60>) of current Near_Edge 454.The last byte of the instruction is in page 453, indicated by done_frame(bits <27:12>) 444, 453 a of current Near_Edge 454. The last byte of theinstruction will fall at byte (((done_byte 445 (bits<43:32>)+done_length 441 (bits <63:60>)−1)mod 4096)), which willnecessarily equal ((next_byte 449 (bits <11:00>)−1)mod 4096). The firstbyte of the next sequential instruction 456 falls in page 453, asindicated in next_frame 448, 456 a (bits <27:12>) of current Near_Edge440, 454, at byte next_byte 449 (bits <11:00>). Because the maximumlength 441 of an instruction (fifteen bytes) is less than the length ofa page, done_frame 453 a of previous profile entry 455 will necessarilyequal Next_Frame 456 a of current Near_Edge 454 in thepage-straddling-instruction case shown in FIG. 4 e.

If instruction 450 is entirely within page 452 and ends exactly at thepage boundary 451, and is not a control transfer (or is a controltransfer that falls through sequentially), then a Near_Edge 440, 454will be generated whose done_frame 453 a will point to page 452, andwhose next_frame 456 a will point to the following page.

Referring to FIG. 4 f, consider another example, a page-straddle controltransfer instruction 450 that touches three pages, the two pages 452,453 on which the source instruction itself is coded, and page 458 onwhich the destination instruction 457 begins. Event code 446 of currentNear_Edge entry 454 records the nature of the control transfer, codes1.0000 through 1.1100 (FIG. 4 b). As in the sequential flow case of FIG.4 e, transfer instruction 450 begins in page 452, as indicatedidentified in next_frame field 438, 448, 452 a of immediately previousprofile entry 455, at a byte offset indicated by next_byte 439 (bits<43:32>) of current Near_Edge 455. The length of instruction 450 isindicated in done_length 441 of current Near_Edge 454. Instruction 450ends in page 453, as indicated by done_frame 444, 453 a (bits <59:44>)of current Near_Edge 440, 454, at byte ((done_byte 445 (bits<43:32>)+done_length 441 (bits <63:60>)−1)mod 4096), each taken from thecurrent Near_Edge 440, 454. Destination instruction 457 begins in page458, as indicated by next frame 448, 458 a (bits <27:12>) of the currentNear_Edge 454, at byte offset next_byte 449 (bits <11:00>). For apage-straddling branch 450, done_frame 444, 453 a (bits <59:44>) ofcurrent Near_Edge 454 now disagrees with the next_frame 438, 448 of theprevious entry, because of the page straddle.

If a profile packet is initiated on a control transfer instruction, thefirst entry will be a Context_At_Point entry 430 pointing to the targetof the transfer instruction.

Referring to FIG. 4 a, the Near_Edge 440 and Context_At_Point 430entries together provide a compact, efficient description of even themost complex control flow, giving enough information to allow hot spotdetector 122 and TAXi binary translator 124 to work, withoutoverwhelming them with an overabundance of information that is notuseful for these two tasks. Note that the requirements of hot spotdetector 122 and TAXi binary translator 124 are somewhat different, sothe information in the profile is designed to superset the requirementsof the two.

In some embodiments, it may be desirable to record a range as the firstbyte of the first instruction to the first byte of the last instruction.Recording ranges in this manner is particularly attractive if thearchitecture has fixed-length instructions.

E. Control Registers Controlling the Profiler

Referring to FIG. 4 g, the TAXi hardware system is controlled by a64-bit register called TAXi_Control 460. TAXi_Control 460 allows finecontrol over profiling. Because much of the system is driven by theprofile, fine control over profiling gives fine control over the entireTAXi system. The various bits allow for enabling and disabling separatepieces of the TAXi mechanism, enabling and disabling profiling for codethat meets or does not meet certain criteria, and timer controls thatcontrol rates of certain events. In any code region for which profilingis disabled, the TAXi resources will be quiescent, and impose nooverhead.

In a typical embodiment, the contents of TAXi_Control register 460 willbe written once during system initialization, to values determined bysystem tuning before shipment. In other embodiments, the values may bemanipulated on the fly, to adapt to particular systems' usage patterns.The one exception is the special_opcode field 434, discussed infra.

Bit <63>, probe 676 is use to enable or disable the probe exception, andwill be discussed in more detail in connection with probing, section VI,infra. Bit <62>, Profile_Enable 464, “prof,” enables and disablesprofile trace packet collection and delivery of the profile trace-packetcomplete exception. The probe 676 and Profile_Enable 464 bits willtypically be manipulated to disable TAXi operation any time the hardwaredebugging resources are active.

Bit <61>, tio 820, indirectly controls the TAXi I/O exception, toprovide one of the guards that implement the safety net introduced atsection I.D, supra, and described in further detail in section VIII.A,infra.

Bit <60>, unpr 468, enables and disables the unprotected exception,discussed in section I.F, supra. Unprotected exceptions are only raisedwhen profiling on unprotected pages.

Field 470, bits <59:56> control the code segment/stack segment sizecombinations that will be profiled. Bit <59>, “c1s1,” enables profilingfor portions of the program whose X86 code segment has its 32-bitdefault operand-size/address-size bit set, and uses a stack in a segmentwhose 32-bit stack bit is set. Bit <58>, “c1s0,” enables profiling for32-bit operand/address, 16-bit stack segments. Bit <57>, “c0s1,” enablesprofiling for 16-bit. operand/address, 32-bit stack segments. Bit <56>,“c0s0,” enables profiling for 16-bit operand/address, 16-bit stacksegments.

Bit <55>, “pnz,” enables profiling for code in privilege rings one, two,and three (Not Equal to Zero).

Bit <54>, “pez,” enables profiling for code in privilege ring zero(Equal to Zero).

Bits <53>, <52>, and <51>, “v86,” “real,” and “smm” (with the size andmode controls of bits <59:54>, collectively known as theGlobal_TAXi_Enables bits 470, 472), enable and disable profiling forcode in the virtual-8086, real, and system management execution modes ofthe X86 (these execution modes indicated by system flags and the IOPLfield in the X86 EFLAGS register). If a given X86 execution mode is notsupported by TAXi (in the sense that TAXi will not attempt to producetranslated native Tapestry binaries for code of that X86 mode), thesystem is designed to impose no overhead on code in that mode. Thus,when the Global_TAXi_Enables 470, 472 bit for a mode is Zero and virtualX86 310 is executing in that mode, then execution is not profiled, theprofile timer (492 of FIG. 4 i) does not run, and the profile,unprotected, and probe exceptions are all inhibited.

Bits <50:44>, special_opcode 474 are used to set the contents ofContext_At_Point profile entries 430. X86 emulator 316 setsspecial_opcode 474 to a desired value. When an RFE with event code0.1010 (FIG. 4 b) is subsequently executed, the contents ofTAXi_Control.special_opcode 474 are copied unmodified into thespecial_opcode field 434 (bits <50:44>) of a Context_At_Point event 430.

Bits <43:38>, Packet_Reg_First 476, and <37:32>, Packet_Reg_Last 478,specify a range of the general registers to be used to accumulateprofile trace packets. The first Context_At_Point entry 430 of a packetwill be stored in the register pointed to by Packet_Reg_First 476, thenthe next entry in register Packet_Reg_First+1, and so on, until the lastentry is stored in Packet_Reg_Last 478. Then a “profile full” exceptionwill be raised (536, 548 of FIG. 5 a), so that the profile registers canbe spilled to memory. As shown in Table 1, typically Packet_Reg_First476 will be set to 17, and Packet_Reg_Last 478 to 31.

Bits <31:16>, Profile_Timer_Reload_Constant 494, and <15:00>Probe_Timer_Reload_Constant 632 (bits <15:00>) are used to control therate of profile trace-packet collection and probing respectively. Thisis further discussed in connection with the TAXi_Timers register (490,630 of FIG. 4 i; see the discussion of FIG. 4 i infra, and thediscussion of probing in sections VI.C and VI.D, infra).

Referring to FIG. 4 h, the internal state of the TAXi system isavailable by looking at a register called TAXi_State 480. In the normalrunning of the system, the TAXi_State register 480 is read-only, thoughit is read-write during context switching or design verification.

Bit <15>, “preq” or “Profile_Request” 484, indicates that profile timer492 has expired and posted the request to collect another packet, buteither no event has yet been encountered to initiate the packet, orprofile timer 492 expired while a packet was actively being collected.

Bit <31>, “pact” or “Profile_Active” 482, indicates that preq“Profile_Request” 484 was set and that an Initiate Packet event (418 ofFIG. 4 b) was encountered and a profile packet has been initiated and isin progress, but the profile registers are not yet filled.

The unused bits of the register are labeled “mbz” for “must be zero.”

The “Decoded_Probe_Event” 680 and “Probe_Mask” 620 fields will bediscussed in section VI, infra.

The “Event_Code_Latch” field 486, 487, bits <12:08>, records a 5-bitevent code (the event codes of FIG. 4 b, or the four-bit events of aContext_At_Point entry 430 of FIG. 4 c or Near_Edge profile entry 440 ofFIG. 4 d), as a retrospective view of the last event that was generatedin converter 136 or encoded as the immediate field in an RFE instruction(588 of FIG. 5 b). Event_Code_Latch 486, 487 serves as anarchitecturally visible place to log the event code until the nextlogical cycle of this process. The four low order bits 486 are suppliedby the RFE immediate field 588 or four bits from converter 136 (582 ofFIG. 5 b). The high-order bit 487 is supplied by context, either One forevents from converter 136, or Zero for events from an RFE.

The “Packet_Reg” field 489, bits <05:00>, gives the number of theregister into which the next profile entry will be written, as apost-increment direct address into the register file. WhenTAXi_State.Packet_Reg 489 exceeds TAXi_Control.Packet_Reg_Last 478,profile collection is terminated, a Profile Packet Complete exception israised, and the value of TAXi_State.Packet_Reg is reset toTAXi_Control.Packet_Reg_First 476.

Referring to FIG. 4 i, TAXi_Timers register 490 has two sixteen-bitcountdown timers 492, 630.

TAXi_Timers.Profile_Timer 492 (bits <31:16>) counts down at the CPUclock frequency when profile collection is enabled as described in thefollowing paragraph. Profile_Timer 492 is an unsigned value that countsdown to zero. On expiry, hardware reloads profile timer 492 with thevalue TAXi_Control.Profile_Timer_Reload_Constant (494 of FIG. 4 g).Profile_Timer 492 continually counts down and reloads. The transition tozero is decoded as timer expiration as defined in the profile exceptionstate diagram (FIG. 5 a).

Profile collection is enabled, and profile timer 492 runs, when thesefive conditions are met: (1) TAXi_Control.Profile_Enable 464 is One, (2)converter 136 is active (PSW.ISA bit 194 indicates X86, see section II,supra), (3) all bytes of the current instruction have 4K page I-TLBentries, (4) all bytes of the current instruction have I-TLB pageattributes in well-behaved memory (Address space zero, withD-TLB.ASI=Zero, is well-behaved, and the other address spaces areassumed to reference non-well-behaved memory) and (5) the machine iscurrently executing in a mode enabled in theTAXi_Control.Global_TAXi_Enables bits 470, 472 (bits <59:51>). When X86debugging or single-step operation is requested, software clearsTAXi_Control.Profile_Enable 464 to disable profile collection.

TAXi_Timers.Probe_Timer 630 (bits <15:00>) is discussed in sections VJ.Cand VI.D, infra.

F. The Profiler State Machine and Operation of the Profiler

Referring to FIG. 5 a, profiler 400 operates according to state machine510. The four states 512, 518, 530, 542 of state machine 510 areidentified by the values of the TAXi_State.Profile_Active 482 andTAXi_State.Profile_Request 484 bits. The transitions ofTAXi_State.Profile_Active 482 and TAXi_State.Profile_Request 484 bits,and thus of state machine 510, are triggered by timer expiry,profileable events, and packet aborts. Event “pe” indicates completionof a profileable event in the execution of the X86 program, one of theevents enumerated as “profileable” 416 in table of FIG. 4 b. Timerexpiry is the countdown-to-zero-and-reset of timerTAXi_Timers.Profile_Timer 492, as described in connection with FIG. 4 i,supra. Aborts are described further infra.

State 512 is the initial state, with Profile_Active 482 (PA) andProfile_Request 484 (PR) both equal to Zero. In state 512, profileableevents 416 and abort events are ignored, as indicated by the looptransition 514 labeled “pe, ap.” When the profile timer 492 expires,TAXi_State.Profile_Request 484 is set to One, which transitions 516state machine 510 to state 518.

In state 518, Profile Request 484 is One and Profile_Active 482 is Zero,indicating that the Profile_Timer 492 has expired, priming profiler 400to begin collecting a profile packet. But that first profileable event416, 418 has not yet occurred, so profiling is not yet in activeprogress. In state 518, further timer expirations are ignored (looptransition 520), rather than queued. Aborts are also ignored (looptransition 520), as there is no profile packet content to abort.

The first entry in a profile packet is always an event with the“Initiate Packet” property (418 of FIG. 4 b). State 518 waits until thefirst “initiate packet” pe_(init) event 418 occurs, initiatingtransition 522. Profileable events (416 of FIG. 4 b) that are not“Initiate Packet” events (418 of FIG. 4 b) are ignored, indicated by the“pe_({overscore (init)})” label on loop transition 520. On transition522, several actions 524 are initiated. TAXi_State.Packet_Reg 489 isinitialized from TAXi_Control.Packet_Reg_First 476. The hardwarecaptures a timestamp from the Global_Timestamp processor register intothe Packet_Timestamp control register (or, in an, alternativeembodiment, into the general register preceding the first profile eventcapture register). A Context_At_Point profile entry 430 is captured intothe general register indicated by TAXi_State.Packet_Reg 489. At decisionbox 526, TAXi_State.Packet_Reg 489 is incremented, and compared againstTAXi_Control.Packet_Reg_Last 478. For the first profile entry, thepacket registers will never be full, so control follows path 528.TAXi_State.Profile_Active 482 is set to One, andTAXi_State.Profile_Request 484 is cleared to Zero, putting state machine510 in state 530.

This first entry in a packet is the only circumstance in which converter136 can generate a Context_At_Point entry 430. For second-and-followingentries in a profile packet, converter 136 only generates Near_Edgeentries 440. Any subsequent Context_At_Point entry 430 in the packet isgenerated by the RFE mechanism.

In state 530, Profile_Request 484 is Zero and Profile_Active 482 is One.At least one profileable event (416 of FIG. 4 b) has been recognized andrecorded, a profile packet 420 is in progress, and profiler 400 isawaiting the next profileable event 416. When the next profileable event416 occurs 532, the profileable event is recorded 534 in the generalregister indicated by TAXi_State.Packet_Reg 489. After the event iscaptured by a TAXi instruction (see discussion of FIG. 5 b, infra),control reaches decision box 526. If the range of profile registers isnot full (TAXi_State.Packet_Reg 489++<TAXi_Control.Packet_Reg_Last478—the old value of TAXi_State.Packet_Reg 489 is tested and thenTAXi_State.Packet_Reg 489 is incremented), then control returns 528 tostate 530 to collect more profileable events 416. If the profileregisters are full (TAXi_State.Packet_Reg 489 equalsTAXi_Control.Packet_Reg_Last 478), then the machine takes a profileexception 536. TAXi_State.Packet_Reg 489 is incremented after thecomparison. The profile exception handler stores the collected profileinto a ring buffer in memory, along with the timestamp captured byaction 524. The ring buffer write pointer, pointing to the next locationin the ring buffer, is maintained in R15 (“RingBuf” Table 1). After thecollected profile packet is stored at the location indicated by R15, R15is postincremented by the size of a profile packet.TAXi_State.Profile_Active 482 and TAXi_State.Profile_Request 484 areboth cleared to Zero, and control returns 538 to start state 512.

If TAXi_Timers.Profile_Timer 492 expires while state machine 510 is instate 530, that is, while a profile packet was in progress, statemachine 510 sets TAXi_State.Profile_Active 482 andTAXi_State.Profile_Request 484 both to One, and transitions 540 to state542.

The behavior of state 542 is largely similar to state 530, in that apartially-complete packet is in progress, and new profileable events 416are logged 544 as they occur. The difference between states 530 and 542arises when the packet is complete. A profile-registers-full exception548 from state 542 spills the profile registers to memory, just asprofile exception 536, but then as part of transition 546,TAXi_State.Profile_Request 484 is set to One, to transition to state518, instead of to Zero as in transition 538, which transitions intostart state 512 to await the next timer expiry 516. From state 518,collection of the next packet can begin immediately on the next“initiate packet” event 418, rather than awaiting another timer expiry516. This effects one level of queuing of pending timer expiries.

Collection of a profile packet may be aborted 550, 552 mid-packet by anumber of events. For instance, an abort packet event code is provided(row 0.1011 of FIG. 4 b)—an RFE with this event code clearsTAXi_State.Profile_Active 482, which in turn discards the currentprofile packet and aborts profile collection until at least the nextprofile timer expiry. If the predicate for enabling profiling (from thediscussion of TAXi_Control 460 in section V.E, supra) becomesunsatisfied, then the packet is aborted. For instance, a packet will beaborted if control passes to a page that is not well-behaved memory (forinstance, a page on the I/O bus), or a byte of instruction lies on apage that does not have a 4K page I-TLB entry, or the X86 execution modetransitions to a mode for which profiling is not enabled in theTAXi_Control.Global_TAXi_Enables bits 470, 472. This abort protocol 550,552 assures hot spot detector 122 that each packet describes an actualexecution path of the X86 machine, without omission.

A transition from X86 code to Tapestry code (for instance, a successfulprobe exception, see section VI, infra) may be an abort 550, 552 event.Profiler 400 is configured to allow the choice between entirelydiscarding the aborted packet or padding out and then spilling thepartial packet to the ring buffer before abort 550, 552 occurs. Thischoice is implemented in the code of the X86-to-Tapestry transitionhandler 320.

FIG. 5 b is a block diagram of a portion of profiler 400, the logic 554to collect and format a profile entry 430, 440 into a processorregister. The inputs to logic 554 include TAXi_State register 480, and anumber of lines produced by X86 instruction decode logic 556 withinconverter 136. The output of logic 554 is a profile entry in register594. Logic 554 as a whole is analogous to a processor pipeline, withpipeline stages in horizontal bands of FIG. 5 b, progressing from thetop of the diagram to the bottom. The stages are clocked at X86instruction boundaries 566. Recall from the discussion of FIG. 1 c thatAlign stage 130 parsed the X86 instruction stream, to identify full X86instructions, and the spatial boundaries in the stored form. Convertstage 134, 136 further decodes X86 instructions and decomposes thecomplex X86 CISC instructions into simple RISC instructions forexecution by Tapestry pipeline 120. The temporal division between X86instructions is marked by a tag 566 on the last instruction of therecipe of constituent Tapestry instructions emitted by converter 136.The temporal boundaries between X86 instructions are flagged in a bit ofthe Tapestry PSW, PSW.X86_Completed 566. The first native instruction inthe converter recipe (which may be a TAXi instruction), resetsPSW.X86_Completed 566 to Zero. The last native instruction in theconverter recipe sets PSW.X86_Completed to One. If a converter recipecontains only one native instruction, then PSW.X86_Completed 566 is setto One. Since an emulator trap is guaranteed to be the last instructionin a converter recipe, upon normal completion of an emulated instructionrecipe, PSW.X86_Completed will be One.

The Tapestry processor provides a special instruction for capturing aprofile entry from processor register 594 into a general register. Thisspecial instruction is called the “TAXi instruction.” The TAXiinstruction is injected into the Tapestry pipeline when a profile entryis to be captured. Recall from the discussion of FIG. 1 c, supra, thatconverter 136 decomposes each X86 instruction into one or more Tapestryinstructions according to a “recipe” for the X86 instruction. The TAXiinstruction is simply one more Tapestry instruction injected into thepipeline under the cooperation of profiler 400 and converter 136. Thus,profile generation is an integral part of the basic Tapestry instructionexecution cycle. The TAXi instruction is typically injected into thepipeline at the beginning of the recipe for the instruction at thedestination of a control transfer. At the choice of the hardwareimplementer, the TAXi instruction may be either a special moveinstruction not encodeable in the Tapestry instruction set, or it may bea move from a processor register. Depending on implementation choice,the instruction can take the form of a “move from register 594 togeneral register TAXi_State.Packet_Reg 489” or converter 136 can extractthe contents of register 594 and inject a move-immediate of this 64-bitdatum into the profile collection general register specified byTAXi_State.Packet_Reg 489.

Instruction decode logic 556 of the Align and Convert pipeline stages(130, 134, 136 of FIG. 1 c) produces signals 558-562 describing thecurrent instruction and certain other profileable properties of eachinstruction, and this description is latched. The information generatedincludes the instruction length 558 (which, if the instruction generatesa profileable Near_Edge event 416, will end up as done length 441 (bits<64:61>) of a Near_Edge entry 440), the page frame for the last byte ofthe instruction 559 (done_byte 445 (bits <59:44>) of a Near_Edge entry440), and the page frame 560 and byte offset 561 of the first byte ofthe next instruction (bits <27:00>, the next_frame 438, 448 andnext_byte 439, 449 of a Near_Edge 440 or Context_At_Point 430). Alsogenerated by decode logic 556 is a raw event code 562 associated withthe X86 instruction when that instruction is executed by converter 136,an indication of whether the instruction ends on or straddles a pageboundary 563, whether the instruction is a control transfer (conditionalor unconditional) 584, whether a PC-relative branch is forward orbackward, and whether converter 136 is currently active (which in turnis copied from the PSW) 590.

At the next X86 instruction boundary 566, the information from thejust-completed instruction is clocked from signals 558, 559, 561 toregisters 568, 569, 570. Registers 568, 569, 570 are simply a buffer fortime-shifting information about an X86 instruction to make it availableduring the next instruction, in case a profile event is to be captured.Because the native control transfer instruction is always the lastinstruction of the recipe for an X86 transfer instruction, thevirtual-to-physical translation of the address of the destination of thetransfer (especially in the case of a TLB miss) is not available untilthe transfer instruction itself is complete. If an event is to becaptured, the TAXi profile capture instruction is injected into thepipeline as the first instruction in the recipe of the destinationinstruction. Thus, the time shifting defers the capture of the profileevent until the address translation of the destination is resolved.Registers 569, 570 together drive a 28-bit bus 572 with the “done” part(bits <59:32>) of a Near_Edge profile entry 430.

Simultaneously, the X86 processor context for the current X86instruction is made available on a 28-bit bus 574, in a form thatparallels bits <59:32> of a Context_At_Point entry 440.

Event codes are generated by circuits 576, 591, and used to controlcapture of profile entries, as follows.

X86 instruction decode logic 556 generates a new raw event code 562 foreach X86 instruction. This event code designates a control transferinstruction (event codes 1.0000-1.1011 of FIG. 4 b), an instruction thatstraddles or ends on the last byte of a page frame (code 1.1111, 408 ofFIG. 4 b), or the default converter event code (1.1110, 406 of FIG. 4 b)for all other cases. (For instructions executed in emulator 316, asconverter 136 parses the instruction, logic 576, 578 generates thedefault event code 1.1110 406 or page-straddle event code 1.1111 408,and then this raw event code 562 is overwritten or selected by the eventcode immediate field 588 of the RFE instruction at the end of the X86instruction's emulation routine.)

If the instruction is not a control transfer instruction, the twospecial “non-event” event codes 1.1110 406 and 1.1111 408 (sequentialflow or page straddle) are manufactured by circuit 578, using the“straddles a page boundary” signal 563 to set the low-order bit.

MUX 580 generates final converter event code 582, selecting between theraw event code 562 generated by instruction decode logic 556 and the1.111x non-event event code 406, 408 from circuit 578 by the followingmechanism. If the current instruction is a “control transfer” (either anunconditional or a conditional transfer) as indicated by line 584, orthe branch predictor predicts 586 that the branch is taken, then MUX 580selects the raw event code 562 generated by decode logic 556, else MUX580 selects the non-event event code from 1.111x circuit 578.

When the branch is predicted 586 taken, MUX 580 selects the rawconditional branch event code 562 associated with the instruction. Whenthe branch is predicted 586 not taken, MUX 580 selects the 1.111xnon-event event code (either the page boundary event code 1.1111 408 orthe default event code 1.1110 406) from circuit 578. Recall that thenative control transfer instruction is always the last instruction ofthe recipe for an X86 transfer instruction, and that the TAXi profilecapture instruction is injected into the pipeline as the firstinstruction in the recipe of the destination instruction of aprofileable transfer. Thus, if it turns out that the branch prediction586 was incorrect, the entire pipeline (120 of FIG. 1 c) downstream ofconverter 136 is flushed, including the TAXi instruction that wouldcapture the contents of register 594 into the next general registerpointed to by TAXi_State.Packet_Reg 489. (This is because the TAXiinstruction is injected into the pipeline following the native branchinstruction that ends the X86 recipe.) The instruction stream is rerunfrom the mispredicted branch. The branch prediction line 586, on rerun,will be asserted to the correct prediction value, and MUX 580 will thusselect the correct event code, and the TAXi instruction will correctlybe injected or not injected. This event code resolution allows theprofile packet to correctly record taken branches or taken conditionalbranches that straddle (or end on) a page boundary, and to correctlyomit capture of not-taken branches that do not cross a page boundary.

For emulated instructions, converter 136 always supplies an event code582 that is either the default or new page event code 578. Sinceconverter 136 completely decodes all instructions, it could supply theevent code corresponding to far control transfer instructions (far CALL,far JMP, far RET or IRET) instead of the default or new page event code578. This event code is latched as part of the emulator trap recipe.When the emulator completes an instruction that straddles a page frameand RFE's back to converter 136 with the simple X86 instruction completeevent code 0.0001, the new page event 1.1111 408 in Event_Code_Latch(486, 487, bits <44:40> of FIG. 4 i) will be used. Since the high-orderbit is set, a reuse event code 414 RFE will result in a Near_Edgeprofile entry being captured; this is correct, because the RFE impliesno data-dependent alteration of context that would require aContext_At_Point. If emulator 316 supplies an RFE event code thatdoesn't reuse 414 the Event_Code_Latch, then the RFE event code 588 willbe latched. This convention allows the profile packet to record eitherinteresting emulated instructions or simple emulated instructions thatstraddle a page frame.

Similarly, if an X86 instruction fails and must be restarted, theprofile information 558, 559, 560, 561, 562, 563, 584 for theinstruction is regenerated and runs down the profile pipeline 554 inparallel with the instruction. For instance, if an instruction fetchmisses in the TLB, the TLB miss routine will run to update the TLB, andthe instruction will be restarted with regenerated profile informationin the profile pipeline.

When an event code comes from the immediate field 588 of an RFEinstruction (410 of FIG. 4 b), Converter_Active line 590 is used both asthe select line 590 a into MUX 591 to select between the converter eventcode 582 and the RFE-immediate event code 588 for the four low-orderbits, and also supplies the high-order bit 590 b of the event code 402,to form a five-bit event code 592. This event code 592 is latched intoTAXi_State.Event_Code_Latch (486, 487, bits <44:40> of FIG. 4 i). (Thereader may think of TAXi_State.Event_Code_Latch 486, 487 as being partof the pipeline stage defined by registers 568, 569, 570.) Not shown inFIG. 5 b is the effect of “reuse event code” 414 of FIG. 4 b: when anRFE instruction completes with a “reuse event code” event code immediate(0.0000 through 0.0011), update of TAXi_State.Event_Code_Latch 486, 487is suppressed, and the old event code is left intact.

Each X86 instruction materializes either a Context_At_Point entry 430 ora Near_Edge entry 440 into 64-bit register 594. The two possible sets ofbits 568, 572, 574 are presented to MUXes 596 a, 596 b, and bitTAXi_State.Event_Code_Latch<4> 487 selects between them. Note, forinstance, that TAXi_State.Profile_Active 482 must be True (states 530and 542 of FIG. 5 a) in order to generate a One from AND gate 598 togenerate a Near_Edge entry 440; this enforces the rule that a Near_Edgeentry 440 must always be preceded by a Context_At_Point entry 430. Thus,a Context_At_Point entry is always forced out ifTAXi_State.Profile_Active 482 is Zero (states 512 and 518 of FIG. 5 a)when a TAXi instruction is issued.

If profiler 400 decides that the entry in register 594 ought to actuallybe captured into a profile, converter 136 injects a TAXi profile captureinstruction into the Tapestry pipeline 120 at the boundary 566 betweenthe profiled X86 instruction and the next X86 instruction, in order tocapture the profile information from register 594.

In some embodiments, it may be desirable to inject multiple TAXiinstructions to capture different kinds of profile information. Forinstance, multiple TAXi instructions could capture a timestamp, acontext (analogous to a Context_At_Point entry 430), a control flowevent (analogous to a Near_Edge entry 440), or one injected instructioncould compute the desired information, and the next instruction storethat information to memory. It may be desirable to temporarily collectthe profile information into a register that is not addressable in thearchitecture, to reduce contention for the storage resource. Whileregister conflict scheduling hardware would have to be used to scheduleaccess to this temporary register, the addition of this register wouldisolate the operation of profiler 400 from other portions of theprocessor.

The TAXi instruction is injected (and a “pe” event 416 triggers atransition in state machine 510 of FIG. 5 a) when all of the followingconditions are met: (1) the machine is currently executing in a modeenabled in the TAXi_Control bits <53:51> (that is, the AND of thecurrent X86 instruction context and TAXi_Control.Global_TAXi_Enables470, 472 is non-zero), (2) the machine is at an X86 instructionboundary, (3) all bytes of the current instruction have 4K page I-TLBentries, (4) all bytes of the current instruction have well-behaved(address space zero) memory I-TLB entries, and (5) at least one of theseis true: (a) profile collection is enabled (TAXi_State.Profile_Active482 is One) and TAXi_State.Profile_Request 484 is One andTAXi_State.Profile_Active 482 is Zero and the event code currentlylatched in TAXi_State.Event_Code_Latch 486, 487 has the “initiatepacket” property (418 of FIG. 4 b), or (b) TAXi_State.Profile_Active 482is One and the event code of TAXi_State.Event_Code_Latch 486, 487 is“profileable” (416 in FIG. 4 b), or (c) a TAXi probe exception will begenerated (this is ancillary to profiling, but rather is a convenientmechanism to control probing, see sections VI.C and VI.D, infra).

During an interrupt of the orderly execution of X86 instructions, forinstance during a TLB miss, page fault, disk interrupt, or otherasynchronous interrupt, the machine queries X86 converter 136 andswitches to native execution. During native execution, X86instruction-boundary clock 566 is halted. Because X86 clock 566 ishalted, the Near_Edge state of the previous X86 instruction is held inregisters 568, 569, 570 until X86 execution resumes.

Note that in the embodiment of FIG. 5 b, profiling is only active duringX86 execution. In an alternative embodiment, profiler 400 is activeduring execution of native Tapestry instructions translated from X86 byTAXi translator 124, so information generated by profiler 400 can be fedback to the next translation to improve optimization the next time theportion is translated. The register usage of the Tapestry program isconfined by the compiler, so that the profile entries can be stored inthe remaining registers.

TAXi_Control.Profile_Timer_Reload_Constant (494 of FIG. 4 g) can betuned by this method. If hot spot detector 122 finds a that the workingset of the program is changing slowly (that is, if a high proportion ofhot spots detected overlap with previously-detected hot spots), thenprofiler 400 is running too often. In this case,Profile_Timer_Reload_Constant 494 can be increased, reducing thefrequency of profiling. Similarly, if hot spot detector 122 is finding alarge change in the working set between hot spot detector runs, thenProfile_Timer_Reload_Constant 494 can be reduced.

An alternative tuning method forTAXi_Control.Profile_Timer_Reload_Constant 494 considers bufferoverruns. When the range of profile collection registers is full, theprofile registers are spilled (536 and 548 of FIG. 5 a) to a ring bufferin memory. The hot spot detector 122 consumes the profile informationfrom this ring buffer. If profiler 400 overruns hot spot detector 122and the ring buffer overflows, then the value inTAXi_Control.Profile_Timer_Reload_Constant 494 is increased, to reducethe frequency at which profiling information is collected.Alternatively, on a buffer overrun, the frequency at which hot spotdetector 122 runs can be increased.

G. Determining the Five-bit Event Code From a Four-bit Stored Form

Referring again to FIGS. 4 b, 4 c, and 4 d, the event code field 436,446 in a profile entry (either a Context_At_Point entry 430 or aNear_Edge entry 440) is four bits. Because the four bits can only encodesixteen distinct values, and thirty-two classes of events are classifiedin FIG. 4 b, the high order bit is recovered as follows.

A Near_Edge entry 440 can never be the first entry in a packet. Theelided high-order bit is always a One, and thus a Near_Edge entry 440always records an event from the lower half 404 of the table of FIG. 4b. The event was always generated by converter 136 (or 1.111x non-eventcircuit 578), and was materialized at line 582 of FIG. 5 b.

When a Context_At_Point 430 is not the first entry in a packet, theelided high-order bit is always a Zero, reflecting an event from theupper half 410 of the table of FIG. 4 b. These non-initialContext_At_Point entries 430 were always generated by RFE events.

Every packet begins with a Context_At_Point entry 430, and thatContext_At_Point is an event with the “initiate packet” property (418 ofFIG. 4 b). The event codes 402 are carefully assigned so that only oneRFE event code (lower half 404 of FIG. 4 b) and converter event code(upper half 410 of FIG. 4 b) both share identical low-order four bitsand are also have the “initiate packet” property 418. These two areevent codes 0.0110 and 1.0110, near RET and far RET. Thus, thehigh-order fifth bit can be recovered from the four bit event code 436,446 of the first event in a packet by a lookup:

-   -   0000→1 1000→0    -   0001→1 1001→0    -   0010→1 1010→1    -   0011→1 1011→1    -   0100→1 1100→0    -   0101→1 1101→0    -   0110→* 1110→0    -   0111→1 1111→0        Near and far returns (0.0110 and 1.0110) share the same four        low-order bits, and either may appear at the beginning of a        packet. An implementation may choose to recover either a 0 or 1.        The ambiguity is an acceptable loss of precision.        H. Interaction of the Profiler, Exceptions, and the XP        Protected/unprotected Page Property

Exceptions interact with profile collection in several ways.

A first class of exceptions are handled completely by the TapestryOperating System (312 of FIG. 3 a). These include TLB, PTE, and PDEexceptions and all native-only exceptions. After handling the exception,sequential execution resumes, with no profile entry collected. The RFEinstruction at the end of these exception handlers uses the sequential0.0000 unchanged event code.

A second class includes TAXi profiling exceptions, including theprofile-register-full exception and unprotected exception (see sectionI.F, supra). Exceptions in this second class have special side effectsdefined by the TAXi environment. These exceptions resume instructionexecution and use special RFE event codes to control the profilingenvironment.

A third class includes all emulator traps from converter 136 for x86instruction emulation. Exceptions in the third category provideadditional profile information. Emulator 316 always uses a non-zero RFEevent code to resume converter operation.

A fourth class includes asynchronous x86 transfers of control fromhardware interrupts, page faults, breakpoints, single step, or any otherx86 exception detected in converter 136 or emulator 316 that must bemanifest to the x86 virtual machine. Exceptions in the fourth class havespecial capabilities. When emulator 316 is about to cause a change ofcontrol flow through the x86 IDT, it uses one of four software definedevent codes in the RFE. These event codes are divided into twocategories. One category is used just for profiling and the other isused to allow emulator 316 to force a check for translated code on anyx86 code page. Emulator 316 maintains a private data structure to testthat a probe check should be generated for a particular ISR address.

The “unprotected” exception (see section I.F, supra) and profiler 400interact as follows. One of the effects of an unprotected exception isto issue a TAXi instruction to start a new profile packet. Recall thatthe unprotected exception is triggered when an X86 instruction isfetched from an unprotected, profileable page:

-   -   TAXi_State.Profile_Active 482==1 //profiling    -   TAXi_Control.unpr 468==1 //exception enabled    -   Page's I-TLB.ISA 182==1 and XP 186=0 //unprotected    -   Fetch page is 4 KB //no abort . . .    -   Fetch page is ASI==0 //no abort . . .        TAXi_State.Profile_Active 482 is set to prime the collection of        a packet in the cycle when an “initiate packet” (418 in FIG. 4        b) event is recognized. A TAXi instruction is sent flowing down        the pipe to update TAXi_State.Profile_Active 482 in the        following cycle, after the translated fetch address is known and        the next instruction has been successfully fetched. A TAXi        instruction is issued when TAXi_State.Profile_Active 482 is        clear, TAXi_State.Profile_Request 484 is set and        TAXi_State.Event_Code_Latch 486, 487 contains an event_code for        which Initiate_Packet 418 is true or the first instruction in a        converter recipe is issued and TAXi_State.Profile_Active 482 is        set. The unprotected exception handler may choose whether to        preserve or discard the current profile packet, keeping in mind        that profile collection on any page that is not protected is        unsafe, since undetected writes to such a page could lead to an        incorrect profile database. When TAXi_Control.unpr 468 is clear,        no exception is generated and TAXi software is responsible for        validating the profile packet and setting the “Protected” page        attribute.

There are two narrow exceptions to the rule that all pages referenced ina profile packet must be protected—the boundary cases at the beginningand end of the packet. If a profile packet (e.g., 420 of FIG. 4 a) endswith a control transfer instruction, the last byte of the transferinstruction, and thus the source of the transfer (the done_frame member444), must be on a protected page, but the destination of the transfer(the next_frame member 438, 448 of the entry) need not be. Similarly, ifa packet begins with a control transfer instruction (one having the“initiate packet” property, 418 of FIG. 4 b), the destination of thetransfer (next frame 438, 448) must be on a protected page, but thesource need not be. In the latter case, the source will escape mentionin the profile packet as a matter of course, because a packet must beginwith a Context_At_Point entry (430 of FIG. 4 c), which does not mentionthe source of the event.

I. Alternative Embodiments

To provide a good heuristic for when to generate optimistic out-of-ordercode and when to generate conservative in-order code, profile entriesmay record references to non-well-behaved I/O space. One mechanism isdescribed in section VIII.B, infra, converter event code 1.1100 thatrecords accesses to I/O space. In an alternative embodiment, a “profileI/O reference” exception traps into Tapestry operating system 312 on areference to I/O space, when executing from an X86 code page (PSW.ISA194 equals One, indicating X86 ISA), and TAXi_State.Profile_Active (482of FIG. 4 h) is One. At the completion of the exception handler, the RFEimmediate field (588 of FIG. 5 b) will supply a profile event with eventcode 1.1100 to indicate an I/O space reference.

A profile control register may be used to control profiling at a finergrain level. For instance, a register may have 32 bits, where each bitenables or disables a corresponding one of the event classes of FIG. 4b. Another control for profiling is discussed infra, in connection withPLA 650.

VI. Probing to Find a Translation

A. Overview of Probing

Profiler 400 generates a profile of an X86 program. Hot spot detector122 analyzes the profile to identify often-executed sections of code.TAXi binary translator 124 translates the hot spot from X86 code to TAXicode (the Tapestry native code generated by TAXi binary translator 124,functionally equivalent to the X86 binary). Because the X86 binary isleft unaltered, it contains no explicit control flow instruction totransfer control to the TAXi code. “Probing” is the process ofrecognizing when execution has reached a point in an X86 binary that hasa corresponding valid entry point into TAXi code, seizing control awayfrom the X86 binary, and transferring control to the TAXi code.

In one embodiment, each instruction fetch cycle queries of a table. Eachentry of the table maps an X86 physical IP value to an address of a TAXicode entry point. For instance, a large associative memory may map X86physical IP values to entry points into TAXi code segments. The numberof segments of TAXi code will typically be, at most, on the order of afew hundred, and execution can only enter a TAXi code segment at thetop, never in the middle. Thus, only a few hundred entries in themapping will be live at any point in time. Such a sparse mapping can beimplemented in an associative memory roughly the size of one of thecaches. Again, the hit rate in this table will be extremely low.Conceptually, the other embodiments discussed infra seek to emulate suchan associative memory, using less chip real estate.

In another embodiment, the mapping from X86 physical IP value toTapestry entry point is stored in memory in a table, and themost-accessed portions of this mapping table are kept in a cache,analogous to a TLB. Each entry in this mapping table has a valid bitthat tells whether the accompanying entry is or is not valid. The cachedcopy of this table is queried during each instruction fetch cycle.Again, the hit rate in this table will be extremely low.

In another embodiment, a bit vector has a bit corresponding to each byte(or each possible instruction beginning, or each basic block) thatindicates whether there is an entry point to TAXi code corresponding tothat byte of X86 instruction space. Each entry in a mapping tableincludes a machine state predicate, indicating the X86 machine stateassumptions that are coded into the TAXi code associated with the entry,and the address for the TAXi entry point. In this embodiment, probing isimplemented as a three step process: query the bit vector to see if amapping translation exists, and if so, look in the mapping table, and ifthat succeeds, verify that the X86 machine state currently satisfies thepreconditions listed in the table entry. The bit vector is quite large,potentially taking 1/9 of the entire memory. Further, the bit vector andtable queries tend to pollute the cache. In this embodiment, anexception is raised after the bit vector query succeeds, and the tablequery is performed by the exception handler software; thus, an exceptionis only raised for addresses that have their corresponding bits in thebit vector set, addresses that have valid TAXi code entry points.

In another embodiment, each bit in the bit vector corresponds to a pageof X86 code. If there is an X86 instruction somewhere on the page with acorresponding translation, then the corresponding bit in the bit vectoris set. Then, at each event that may be followed by entry to a TAXi codesegment, the mapping table is probed to see if such a translationexists. Thus, this implementation takes less memory to hold the bitvector than the embodiment of the previous paragraph, but generates anexception for every instruction fetch from the pages to query the table,not just the instructions that have corresponding TAXi entry points.This embodiment works especially well if translation is confined to arelatively small number of infrequent events, for instance, subroutineentries, or loop tops.

A bit associated with a page can be cached in the TLB, like the otherpage properties 180, 186.

In the embodiment discussed at length in the following sections, TAXidivides the possible event space by space (pages), time (using the Probetimer), and event code (the same event code 402 used in profiling).

B. Overview of Statistical Probing

TAXi prober 600 uses a set of statistical heuristics to help make aprofitable set of choices about when a TAXi translation is highly likelyto exist in the TAXi code buffer. Rather than probe for a translation onevery occurrence of an event, for instance at every routine call, TAXiprober 600 probes on a larger class of events, including simple controltransfers, conditional jumps, near call, far call and delivery of an X86interrupt, and uses a statistical mechanism to throttle the number ofprobes on the expanded number of classes down to a number likely tosucceed. The statistical probe mechanism is designed to have a highcorrelation between probe exceptions and actual opportunities to executeTAXi code.

TAXi divides the space of possible program events spatially, logically,and temporally, and then forms a statistical association between the X86code space/logic/time that is not always correct, but that is wellcorrelated with the existence of TAXi code. As in the embodimentsdescribed in section VI.A, a table maps X86 physical IP values to entrypoints in TAXi code segments. This table is called the PIPM (Physical IPMap) 602. Each physical page has associated properties. The propertiesare associated with several logical event classes (a subset 612 of theevent classes laid out in FIG. 4 b and discussed in section V.B, supra).Binary translator 124 maintains five bits 624 of properties per page inPFAT (page frame attribute table) 172—when a binary translation iscreated, the bit 624 corresponding to the entry event is set in the X86page's PFAT entry 174 to indicate the existence of the translation, andan entry in PIPM 602 is created that maps the X86 physical IP address tothe address of the TAXi code segment. The five PFAT bits are loaded intothe TLB 116 with the page translation from the page tables. Enablementof the feature that queries these bits is gated by a time-varying probemask, whose bits correspond to the five PFAT/TLB bits.

A probe occurs in several stages, as will be described in detail inconnection with FIG. 6 c. When a stage fails, the rest of the probe isabandoned. The first stage is triggered when an X86 instruction isexecuted, and that instruction generates an event code that is one ofthe probeable event codes, and the corresponding probe property for thepage is enabled, and the corresponding bit in the current probe mask isenabled. The first stage is essentially an implementation of theassociative memory search described for the previous embodiments, but ona memory page granularity. This first stage gives areasonable-but-imperfect evaluation of whether it is likely to beprofitable to generate an exception, so that software can actually probePIPM 602. If this first stage test succeeds, then the processorgenerates a probe exception. A software exception handler probes PIPM602 to discover whether there is a current translation of the current IPvalue, and to find the address of that translation.

This implementation uses no large hardware structures on the Tapestrymicroprocessor chip; for instance, it avoids a large associative memory.The implementation reduces the overhead associated with unsuccessfulprobes of PIPM 602, while providing a high likelihood that executionwill be transferred to the TAXi code that is translated to replace ahots pot of the X86 program.

Recall also that probing is an optimization, not a condition for minimumcorrectness. If prober 600 generates too many probe exceptions, theexcess probes of PIPM 602 will fail because there is no translation towhich to transfer control, and correct execution will resume inconverter (136 of FIGS. 1 a and 1 c). The cost of an error is oneexecution of the probe exception handler. If the mechanism generates toofew probes, then control will not be transferred to the TAXi code, andexecution will simply continue in converter 136. The cost of the erroris the opportunity foregone (less the cost of the omitted exception).Because errors do not induce any alteration in the result computed, aheuristic, not-always-correct approach does not violate anyarchitectural correctness criteria. This goal is sought by findingfine-grained ways of slicing up time, space, and classes of events, andassociating a well-correlated indicator bit with each slice.

C. Hardware and Software Structures for Statistical Probing

A number of the structures discussed in section V, supra, in connectionwith profiling are also used in probing.

Referring again to FIG. 4 b, the event code taxonomy 402 for profilingis also used for probing. Column 610 designates a number of events as“probeable.” The events designated probeable 610 are all transfers ofcontrol by an X86 instruction or interrupt. The code at the destinationof the transfer is a candidate for a probe. Hot spot detector 122 isdesigned with knowledge of the probeable event classes, and will onlytranslate a detected X86 hot spot when the control transfer that reachesthe hot spot is one of the probeable events 610. Thus, when an X86program executes a transfer of control, and the transfer is one of theprobeable 610 transfers, there is at least the theoretical possibilityof the existence of TAXi code, and the rest of the probe circuitry isactivated.

The probeable events 610 are further classified into six classes, incolumn 612. The six classes are “far call,” “emulator probe,” “jnz,”“conditional jump,” “near jump,” and “near call.”

Referring again to FIG. 4 h, probe mask 620 is a collection of six bits,one bit corresponding to each of the six probeable classes 612 of FIG. 4b. When a probe mask bit is One, probes for the corresponding class 612are enabled—when an event of that class occurs (and certain otherconditions are satisfied, see the discussion of FIGS. 6 a-6 c, infra),the hardware will trigger a probe exception and a probe of PIPM 602.When a probe mask 620 bit is Zero, probes for the corresponding class612 are disabled—even if a translation exists for the destination of theevent, the hardware will not initiate a probe of PIPM 602 to find thetranslation.

Referring again to FIG. 1 d, a PFAT entry 174 has five bits 624 ofproperties for each physical page. These five bits 624 correspond to the“far call,” “jnz,” “conditional jump,” “near ump,” and “near call”probeable properties (612 of FIG. 4 b, 620 of FIGS. 4 h and 6 b, and660, 661, 662, 663, 664 of FIG. 6 b—the “emulator probe” probe is raisedby software, rather than being maintained on a per page basis). Thecorresponding bit of PFAT probe properties 624 is set to One when hotspot detector 122 has detected a hot spot and binary translator 124 hasgenerated a native Tapestry translation, and the profile for thetranslation indicates the class of events that lead to entry of the X86hot spot that is detected and translated. The five bits 624 of a givenpage's PFAT entry are AND'ed together with the five corresponding bitsof probe mask 620 to determine whether to probe, as described infra inconnection with FIGS. 6 b-6 c.

Referring again to FIGS. 4 g, 4 h and 4 i, TAXi_Timers.Probe_Timer 630is an unsigned integer countdown timer that counts down at the CPU clockfrequency, used to control the average rate of failed probe exceptionson a per-event-class basis. When Probe_Timer 630 counts down to zero,TAXi_State.Probe_Mask 620 is reset to all One's, and Probe_Timer 630 isreset to the value of TAXi_Control.Probe_Timer_Reload_Constant 632. AnRFE with event code 0.0011 forces an early reset of Probe_Timer 630 fromProbe_Timer_Reload_Constant 632.

Together, Probe_Mask 620 and Probe_Timer 630 synthesize the followingbehavior. As long as probes of a class 612 are successful, the machinecontinues to probe the class. When a probe fails, the class 612 of thefailed probe is disabled for all pages, by setting the class' bit inProbe_Mask 620 to Zero. At the next expiry of Probe_Timer 630, allclasses are re-enabled.

Recall that TAXi code segments are created asynchronously to theexecution of the X86 binary, after a hot spot is detected by hot spotdetector 122. Translated code segments are retired when they fall intodisuse. On a round-robin basis, TAXi native code segments are marked asbeing in a transition state, and queued as available for reclamation.The code segment, while in transition state, is removed from all addressspaces. If the TAXi code segment is invoked while in transition state,it is dequeued from the transition queue, mapped into the invokingaddress space, and re-set into active state. If the TAXi code segment isnot invoked while in transition state, the storage is reclaimed when thesegment reaches the tail of the queue. This reclamation policy isanalogous to the page replacement policy used in Digital's VAX/VMSvirtual memory system. Thus, because the reclamation policy is somewhatlazy, PFAT 172 may be somewhat out of date.

Referring to FIG. 6 a in conjunction with FIGS. 1 c, 1 d, 3 a and 4 b,PIPM 602 is a table of PIPM entries 640. Each PIPM entry 640 has threeclasses of information: the X86 physical address 642 that serves as anentry point into a translated hot spot, X86 machine context information646, 648 that was in effect at the time of previous executions and whichnow serves as a precondition to entry of a translated TAXi code segment,and the address 644 of the translated TAXi code segment. The integersize and mode portion 646 of the context information is stored in a formthat parallels the form captured in a Context_At_Point profile entry(430 of FIG. 4 c), and the form used to control profiling in theTAXi_Control.Global_TAXi_Enables bits (470, 472 of FIG. 4 g). If thecurrent size and mode of virtual X86 310 does not match the state savedin the size and mode portion 646 of PIPM entry 640, the probe fails. Thefloating-point portion 648 of PIPM entry 640 parallels thefloating-point state 435 captured in a Context_At_Point profile entry430. If, at the conclusion of an otherwise successful probe, thefloating-point state of virtual X86 310 does not match the state savedin the floating-point portion 648 of PIPM entry 640, then either thefloating-point state is massaged to match the state saved in PIPM entry640, 648, or the probe fails.

Referring to FIG. 6 a in combination with FIG. 1 b, PIPM 602 is keptup-to-date, reflecting the current catalog of translations available,and tracking TAXi code translations as they are created, marked forreclamation, and actually reclaimed and invalidated. The probe bits inPFAT 172 may lag slightly, and the probe bits in TLB 116 are allowed tolag slightly further. Further, the probe bits in TLB 116 only conveyinformation to page granularity. Thus, the probe bits in TLB 116indicate that at some recent time there has been TAXi code with thatentry point class on this page. A Zero bit in TLB 116 suggests thatthere is no such entry point, and that a probe of the PIPM 602 on thisevent class would very likely fail, and thus should not be attempted. AOne suggests a high likelihood of success. The One may be somewhatstale, still indicting the presence of a TAXi code translation that hassince been invalidated and reclaimed. After a hit in TLB 116, a probe ofPIPM 602 will find that the PIPM entry 640 for the reclaimed TAXi codesegment will indicate the invalidity of the TAXi segment, for instance,by a Zero in address 644.

Recall from section V.G, supra, that a fifth high-order bit is needed todisambiguate the four-bit event code stored inTAXi_State.Event_Code_Latch 486, 487 and Context_At_Point profileentries 430. The event codes 402 of FIG. 4 b are carefully assigned sothat no probeable 610 RFE event code (top half 410) shares fourlow-order bits with a probeable 610 converter event code (bottom half404). Probeable 610 RFE events 410, 610 are always even, and probeable610 converter events 404 are always odd. Thus, the least significantfour bits of the current event code uniquely identify the probe event,the probe exception handler can always determine whether the probe eventcame from a RFE instruction or converter execution. (This non-overlap ofprobeable events 610 is an additional constraint, on top of thenon-overlap of “initiate packet” event codes 418 discussed in sectionV.G, supra.) Referring again to FIG. 6 b, probing is controlled by a PLA(programmable logic array) 650 and several AND gates. PLA 650 generatesseveral logic functions of event code 592 from event code latch 486,487. PLA 650 computes the “initiate packet” 418, “profileable event”416, and “probeable event” 610 properties as described in FIG. 4 b. Inaddition, the probeable event codes are decoded into single signals asdescribed in column 612 of FIG. 4 b. For instance, “jnz” bit 660,corresponding to bit <0> of the probe properties 624 of FIG. 1 d, isasserted for event code 1.0001. “Conditional jump” bit 661,corresponding to bit <1> of probe properties 624, is asserted for eventcode 1.0011. “Near jump” bit 662, corresponding to bit <2> of probeproperties 624, is asserted for event code 1.0101. “Near call” bit 663,corresponding to bit <3> of probe properties 624, is asserted for eventcodes 1.0111 and 1.1011. “Far call” bit 664, corresponding to bit <4> ofprobe properties 624, is asserted for event code 0.1000. “Emulatorprobe” bit 665 is asserted for event codes 0.1100 and 0.1110.

D. Operation of Statistical Probing

Referring to FIGS. 6 b and 6 c, for an X86 transfer of controlinstruction (either a simple instruction executed in converter 136 or acomplex instruction executed in emulator 316), the instruction fetch ofthe transfer target ensures that TLB 116 is updated from PFAT 172 withthe current probe page properties 624 for the page of the targetinstruction—either the information was already current in TLB 116, or itis refilled as part of the I-TLB miss induced by the instruction fetch.Thus, as part of the instruction fetch, the TLB provides both an addresstranslation and the probe page properties 624 for the target instruction(though, as discussed in section VI.C, supra, the probe properties inTLB 116 may be slightly stale).

Further, these control transfer instructions generate an event code 402,as described in section V.F, supra. At the conclusion of theinstruction, either converter 136 or an RFE instruction generates a5-bit event code 592. The event code is stored in latch 486, 487. As thetarget instruction is fetched or begins execution, event code latch 486,487 is fed to PLA 650.

Six 3-input AND gates 670 AND together the probeable event signals 660,661, 662, 663, 664, 665 with the corresponding page properties from theTLB (624 of FIG. 1 d) and the current value of Probe_Mask 620. The sixAND terms are OR'ed together in OR gate 672. Thus, the output of OR gate672 is One if and only if the current instruction generated an event 592whose current Probe_Mask 620 is One and whose probe property bit 624 forthe current page is One. The “emulator probe” signal 665 is generated byPLA 650 when RFE event code equals 0.1100 or 0.1110, as indicated by“Emulator Probe” in column 612 of FIG. 4 b. This class of probe israised when emulator 316 believes that probe success is likely and theEmulator Probe bit (bit <5>) of Probe Mask 620 is One.

The sum of OR gate 672 is AND'ed 674 with several more terms. Probing asa whole is controlled by TAXi_Control.probe 676 (see also FIG. 4 g); ifthis bit is Zero, probing is disabled. To ensure that control is onlytransferred to TAXi code whose underlying X86 code is unmodified sincethe translation was generated, probing is only allowed on protectedpages of X86 instruction text, as controlled by XP bit 184, 186 for thepage (see also FIG. 1 d, and sections I.F, supra, and section VIII,infra); if XP bit 184, 186 is Zero, no probes are taken on the page.Probing is controlled for X86 contexts byTAXi_Control.Global_TAXi_Enables.sizes 470 and modes 472 bits, which areset by TAXi system control software. Probing is only enabled for currentX86 modes whose TAXi_Control.Global_TAXi_Enables 470, 472 are set toOne. Probing and profiling are mutually exclusive (see section VI.G,infra); thus probing is disabled when TAXi_State.Profile_Active (482 ofFIGS. 4 h, states 530 and 542 of FIG. 5 a, see section V.E and V.F,supra) is One. If the output 678 of AND gate 674 is One, then theprocessor continues to the next step of determining whether to probePIPM 602, as discussed further infra.

TAXi_Control.probe 676 was Zeroed by software when the X86 processorentered a mode that TAXi is not prepared to handle, e.g., X86 debugging,single-step or floating-point error conditions. When operating in “pageproperty processing disabled” mode (with PROC_CTRL.PP_Enable deasserted,see section I.A, supra), TAXi_Control.probe 676 is deasserted.

The output 678 of AND gate 674 latches the single bit of the probe eventclass into Decoded_Probe_Event latch 680.

An intermediate step 690 to be performed in hardware, discussed indetail in section VI.E, infra, may optionally be performed here.

If all of the hardware checks described supra pass, then the processortakes a probe exception before completing execution of the instructionat the target of the control transfer. The probe exception transferscontrol to software that continues to further test whether controlshould be transferred to the TAXi code.

As part of generating a probe exception, converter 136 writes (step 682)a Context_At_Point profile entry (430 of FIG. 4 c) to the registerindicated by TAXi_Control.Packet_Reg_First (476 of FIG. 4 g) defined forprofile collection. (as will be explained further in section VI.G,infra, profiling and probing are mutually exclusive, and the X86 doesnot use the profile collection registers, so the three uses cannotconflict.) The event code (436 of FIG. 4 c) of the profile entry 430 isset to the least significant 4 bits of the current event code (592 ofFIG. 5 b).

On entry to the probe exception handler the following information isavailable from the converter:

-   -   A Context_At_Point profile entry 430, containing the X86        physical IP (page frame number and page offset) in low half 438,        439    -   X86 execution context, from high half 432, 433, 435 of        Context_At_Point 430    -   probe event code in the event code field 436 of Context_At_Point        430    -   X86 virtual IP (offset into the CS segment) from EPC.EIP

The exception handler consults PIPM 602. PIPM 602 is a table that mapsX86 instruction addresses (their physical addresses, after addresstranslation) to addresses of TAXi code segments. The table entry in thePIPM is indexed by X86 physical address, typically using a conventionalhashing technique or other table lookup technique. The probe exceptionhandler looks up the physical address of the target instruction in thePhysical IP to TAXi code entry point Map (PIPM) 602.

If no PIPM entry 640 with a matching X86 address is found, then theprobe has failed, with consequences discussed infra.

Once a table entry with an address match is located, the translationmust be further qualified by the current X86 mode. Recall that the fullexecution semantics of an X86 instruction is not fully specified by thebits of the instruction itself, execution semantics depend on whetherthe processor is in V86 mode, whether addressing is physical or virtual,the floating-point stack pointer, and the full/empty state offloating-point registers, and operand sizes are encoded in segmentdescriptors, the EFLAGS register, the floating-point status word, thefloating-point tag word, etc. The translation into Tapestry native codeembeds assumptions about these state bits. These state bits wereinitially captured in bits <59:51> of a Context_At_Point profile entry430 (see section V.C, supra) and then hot spot detector 122 and binarytranslator 124 generated the translation based on the profiled values ofthe mode bits. The corresponding PIPM entry 640 for the translationrecords the mode bit assumptions under which the TAXi code segment wascreated. Thus, once PIPM entry 640 is found, the current X86 mode iscompared against the X86 mode stored in PIPM entry 640.

The exception handler makes three general classes of checks of the modeinformation in PIPM 602.

First, the current execution mode and the value of the CS.D (code andoperand size) and SS.D (stack segment size) bits assumed by TAXitranslator 124 must be compatible. This is determined by comparing thedecoded “sizes” information 432 from the Context_At_Point argument withthe mask of acceptable contexts provided in PIPM entry 640, 646.

If the current floating-point state does not match the floating-pointstate 648 in PIPM entry 640, then the probe fails. In some cases,disagreements can be resolved: the floating-point unit can be unloadedand reloaded to conform to the floating-point state in PIPM entry 640,for instance, to get the floating-point registers into the canonicallocations specified by the current X86 floating-point map. If the heightof the floating-point register stack mismatches the stack height in PIPMentry 640, or the pseudo floating-point tag words mismatch, or thefloating-point control words (precision and rounding modes) mismatch,then the probe fails. If the only mismatch is the mapping of thefloating-point tag map (the map from the X86 stack-based register modelto the register address Tapestry model), then software can reconfigurethe floating-point state to allow the probe to succeed.

Execution control is tendered to the TAXi code. If the modes mismatch,the probe fails.

Second, the current virtual IP value must be such that (a conservativeapproximation of) the transitive closure of the TAXi code pointsreachable by invoking this TAXi fragment would not trigger a CS limitexception. This is determined from the virtual IP at the time of theexception and normalized CS limit, and comparing them to values storedin PIPM entry 640.

Third, because the TLB copy of the XP bit 186 may be slightly stalerelative to the PFAT copy 184, the master copy of the XP bit 184 in PFAT172 is checked to ensure that all cached information (the profile andTAXi code) associated with the X86 page is still valid.

Fourth, DMU 700 (see section VII, infra) may be queried to ensure thatthe X86 page has not been invalidated by a DMA write.

If the current X86 mode satisfies the mode checks, then the probe hassucceeded. PIPM entry 640 contains the address of the TAXi codecorresponding to the address of X86 code at which the probe exceptionoccurred. If the modes mismatch, the probe fails.

When a probe exception succeeds, the handler modifies the EPC by settingEPC.TAXi_Active, Zeroing EPC.ISA (native Tapestry mode), setting EPC.EIPto the address of the TAXi code, and setting EPC.ESEG to the specialTAXi code segment. The RFE instruction completes the transfer ofexecution to the TAXi code by loading the EPC into the actual processorPSW. A successful probe leaves the Probe_Mask 620 unaltered. Thus,classes of probeable events remain enabled as long as each probe in theclass is successful.

By resetting EPC.EIP to point to TAXi translated code, the RFEinstruction at the end of the probe exception handler effects atransition to the TAXi code. Because the TAXi code was transliteratedfrom X86 code, it follows the X86 convention, and thus the argumentcopying that would have been performed by the transition exceptionhandler (see sections II, III, and IV, supra) is not required. Further,because both the probe exception handler and the TAXi code are inTapestry ISA, no probe exception occurs on this final transition.

When a probe exception is triggered, and the software probe fails tofind a translation, several steps are taken. The bit in Probe_Mask 620that corresponds to the event that triggered the probe is cleared toZero, to disable probes on this class of event until the next expiry ofProbe_Timer 630. This is accomplished by the Probe_Failed RFE signal andthe remembered Decoded_Probe_Event latch 680. The interrupt serviceroutine returns using an RFE with one of two special “probe failed”event codes of FIG. 4 b. Event code 0.0011 forces a reload ofTAXi_Timers.Probe_Timer 630 with the Probe_Timer_Reload_Constant 632.Event code 0.0010 has no side-effect on Probe_Timer 630. It isanticipated that when a probe on a backwards branch fails, Probe_Timer630 should be reset, by returning from the probe exception with an RFEof event code 0.0011, in order to allow the loop to execute for the fulltimer value, with no further probe exceptions. On the other hand, it isanticipated that when a probe on a “near call” fails, testing other nearcalls from the same page should be allowed as soon as Probe_Timer 630expires, and thus this probe exception will return with an event code of0.0010. The RFE returns to the point of the probe exception, andexecution resumes in converter 136.

If an RFE instruction that modifies Probe_Mask 620 is executed at thesame time that the probe timer expiry attempts to reset Probe_Mask 620,then the RFE action has higher priority and the reset request isdiscarded.

E. Additional Features of Probing

In the intermediate step 690 mentioned briefly supra, a bit vector ofbits indicates whether a translation exists for code ranges somewhatfiner than the page level encoded in the PFAT probe bits. After aprobeable event occurs, and the class of that event is screened againstthe PFAT probe bits and the probe mask, the hardware tests the bitvector (in an operation somewhat reminiscent of a page translation tablewalk) before actually raising the probe exception and transferringcontrol to the software interrupt handler.

Only the slices of the bit vector that correspond to pages with non-zeroPFAT probe bits are actually instantiated by software, again similar tothe way only the relevant portions of a full page table tree areinstantiated by a virtual memory system. The bit vector itself is hiddenfrom the X86 address space, in an address space reserved for the probebit vector and other structures for managing the X86 virtual machine.The bit vector may be cached in the d-cache—because of the filteringprovided by the earlier steps, the number of unsuccessful queries of theprobe bit vector will be relatively small.

The density of the bit vector can be tailored to the operation of thesystem. In some embodiments, there may be a bit for every byte in thephysical memory system. In other embodiments, the effectiveness of thebit vector would most likely be only marginally reduced by having onebit for a small power of two bits, for instance, one bit for every 2, 4,8, 16, or 32 bytes of physical memory. The block size guarded by eachbit of the bit vector may be software configurable.

Thus, where the probe properties 624 in PFAT 172 give a fine-grainedfilter by event code (the five probeable event classes), but arespatially coarse (on a page basis), the bit vector gives a coarse map onevent code (all events grouped in a single bit), but is finely grained(a few bytes) by space.

A One bit in the bit vector is not a guarantee that translated codeexists and should be activated. As with the PFAT probe bits, the bitvector is somewhat over-optimistically heuristic, and may on occasionlag the actual population of translated code segments. Even aftertesting the bit vector, the mode predicates in PIPM 602 are still to beverified.

The quasi-microcoded hardware used for table walking is readily modifiedto issue the loads to memory to fetch the appropriate slices of the bitvector.

The logic of PLA 650 is programmable, at least during initialmanufacture. Reprogramming would alter the contents of columns 414, 416,418, 610, 612 of table at FIG. 4 b. Though the five-bit event codesgenerated by converter 136 are relatively fixed, the interpretationgiven to those bits, and whether to profile or probe on those events, isreconfigurable within PLA 650. In alternative embodiments, PLA 650 maybe made programmable at run time, to control operation of profiling andprobing by altering the contents of the columns of FIG. 4 b. The fivebits of input (event code latch 486, 487) to PLA 650 give 2⁵=32 possibleinputs. There are nine bits of output (probeable event signals 660, 661,662, 663, 664, 665, profileable event 416, initiate packet 418, andprobeable event 610). Thus, PLA 650 could be replaced by a 32%9 RAM, andthe outputs of PLA 650 would then be completely software configurable.With that programmability, both profiling (section V, above) and probing(this section VI) become completely configurable. In a programmableembodiment, the overhead of profiling and probing can be controlled, andstrategies can be adapted to experience.

Most of the attributes required for a probe are associated with pages(stored in the PFAT and TLB), or with individual translated codesegments (stored in PIPM 602), a structure queried by converter 136 assimple X86 instructions are executed in hardware. For complexinstructions that are executed in the emulator (316 of FIG. 3 a) thedecision to probe or not to probe is made in software. A side tableannotates the X86 IVT (interrupt vector table) with probe attributes,much as the PFAT is a side annotation table to the address translationpage tables. After emulating an X86 instruction, emulator 316 queriesthe IVT side table, and analyzes these bits in conjunction with themachine state determined during the course of the emulation. On thebasis of this query, emulator 316 decides whether to return to converter136 using an RFE with an event code that induces a probe, or an RFE withan event code that does not. Event codes 0.1100 and 0.1110 induce aprobe (see column 610 of FIG. 4 b), and event codes 0.1101 and 0.1111 donot.

F. Completing Execution of TAXi Code and Returning to the X86 Code

Once a probe exception activates some translated TAXi code within an X86process, there are only three ways to leave that TAXi code, either anormal exit at the bottom of the translated segment, a transfer ofcontrol out of the code segment, or an asynchronous exit via anexception.

The fall-out-the-bottom case is handled by epilog code generated by theTAXi translator 124. The TAXi code will home all X86 machine state andreturn control to the converter by issuing a trap instruction. A trapinstruction transfers control to an exception handler for a TAXi_EXITexception. The trap handler for exiting TAXi code sets the ISA to X86and returns control to the point in the X86 code following thetranslated hot spot. In the alternative embodiment of section IV, epilogcode returns data to their X86 homes, and sets the IP to point to thepoint following the end of the portion of the X86 code that wastranslated.

The transfer of control case may be handled by the state savingmechanism described in section III, supra, or may be handled by codeessentially similar to the epilog code discussed supra. In any case, theTapestry system takes explicit actions to reconstruct the x86 machinestate.

Asynchronous exits are handled by exception handlers, using the safetynet mechanism introduced in section I.D, supra, and discussed in moredetail in section VIII, infra. When an exception occurs in TAXi code andthe exception handler determines that it must materialize the exceptionin the X86 virtual machine, it jumps to a common entry in emulator 316that is responsible for setting the X86 state—establishing the interruptstack frame, accessing the IDT and performing the control transfer. Whenthis function is invoked, it must first determine if TAXi code was beingexecuted by examining PSW.TAXi_Active 198, and if so, jump to a TAXifunction that reconstructs the X86 machine state and then re-executesthe X86 instruction in the converter to provoke the same exceptionagain. Re-executing the X86 instruction is required to establish thecorrect X86 exception state. Anytime the converter is started tore-execute an x86 instruction, the exception handler uses the RFE withprobe failed, reload probe timer event code to prevent a recursive probeexception from occurring.

The only exceptions that may not be materialized in the x86 world arethose that can be completely executed by native Tapestry code, e.g. TLBmiss that is satisfied without a page fault, FP incomplete with nounmasked X86 floating-point exceptions, etc.

G. The Interaction of Probing and Profiling

Probing and profiling are mutually exclusive. Probing only occurs whenthere is a probeable event (column 610 of FIG. 4 b) whileTAXi_State.Profile_Active (482 of FIGS. 4 h and 5 a) is Zero. Theseconstraints are enforced by AND gate 674 of FIG. 6 b. On the other hand,profiling is only enabled while TAXi_State.Profile_Active 482 is One.Thus, when the processor takes a probe exception, the mutual exclusionguarantees that the resources used by profiling are quiescent. Inparticular, the general registers in which profile packets accumulateare guaranteed to be available for use to service the exception.

Every probeable event 610 is also an “initiate packet” event 418. Thisreflects a practical design consideration: the class of probeable events610 are the most important events in the flow of a program, and“initiate packet” events 418 are a somewhat broader set of importantevents. If a probeable event 610 occurs in a class for which probing isenabled, and TAXi_State.Profile_Active (482 of FIGS. 4 h and 5 a) isZero, then the event is also an “initiate packet” event 418. If,further, TAXi_State.Profile_Request 484 is One, then profiler 400 wouldnaturally trigger a transition of TAXi_State.Profile_Active (482 ofFIGS. 4 h and 5 a) and TAXi_State.Profile_Request 484, transition 522 ofFIG. 5 a. This would violate mutual exclusion. However, the probeexception is higher priority than any activity of profiler 400. Thus, ona successful probe, control is transferred to the TAXi code, and anyprofiler action is suppressed. If the probe fails, the probe class isdisabled, and profiler 400 is allowed to take its normal course, asdescribed in FIGS. 5 a and 5 b and section V.F, supra.

The content of a profile packet, and in particular, a Context_At_Pointprofile entry (430 of FIG. 4 c), is tailored to efficiently representthe information required by hot spot detector 122 (to precisely identifythe ranges of addresses at which frequently-executed instructions arestored), and efficiently tailored for the binary translator 124 (tocapture the X86 semantic mode information that is not represented in thecode text itself), and efficiently tailored for prober 600 (theinformation required to qualify a probe, to ensure that the semanticmode assumptions under which the binary was translated are met by thecurrent X86 semantic mode, before transferring control to the TAXicode). Though the representation is not optimal for any one of thethree, it is very good for all three. In other embodiments, therepresentation may be tailored to promote efficiency of one of the threeover the others, or solely for the benefit of one.

The fact that probeable events 610 are a subset of “initiate packet”events 418 has a further desirable side effect: the hardware to captureinformation for the first profile entry 430 in a packet can be reused tocapture the information needed by the probe exception handler. When adecision is made in hardware to deliver a probe exception, the exceptionhandler is provided with information about the physical address to whichcontrol was being passed and the context of the machine. The informationfor a probe exception is gathered in register 594 of FIG. 5 b, in a formthat mirrors the form captured in a Context_At_Point profile entry 430.In the process of either generating a probe exception in hardware, orservicing it in software, the content of register 594 is captured into ageneral register. This capture (when supplemented with the CS limit(code segment length), as stored in an X86 segment descriptor register)supplies the information needed by the probe exception handler: thephysical address of the next instruction, used to index PIPM 602 andfind a possible candidate entry, and the X86 mode information needed toqualify that entry. The address captured in the Context_At_Point 430 hasthe physical page number, ready for use to index into PIPM 602. Sinceall probeable events are “initiate packet” events, the mode informationis readily available in the Context_At_Point profile entry 430 thatinitiates the packet identifying the hot spot. The various snapshots canbe compared to each other for compatibility by AND'ing the appropriatebits together.

Unlike profile collection, which operates by periodic sampling, probingis always enabled when the converter is active, the TAXi_Control.probeflag is One, and the probe mask has at least one surviving One bit.

H. Alternative Uses of Adaptive Opportunistic Statistical Techniques

The adaptive opportunistic execution policy described in section VI.Athrough VI.E can be used in a number of settings in a CPU design.

In one example embodiment, a CPU might have a fast path and a slow paththrough the floating-point unit, where the fast path omits fullimplementation of the IEEE-754 floating-point infinities, denormalizednumbers (“denorms”) and NaNs, and the slow path provides a full hardwareimplementation. Because infinities, denorms and NaNs tend to ariseinfrequently, but once generated tend to propagate through more and moreof the computation, it is advantageous to start with the optimisticassumption that no denorms or NaNs will arise, and to configure the CPUto use the fast path. Once an infinity, denorm or NaN is detected, thenthe CPU may revert to the slow path. A timer may be set to run, and whenthe timer expires, the CPU will resume attempting the fast path.

In another example embodiment, a cache system might use an analogousadaptive opportunistic technique. For instance, a multi-processor cachemight switch between a write-through policy when inter-processor bussnooping indicates that many data in the cache are shared, write-in whenit is noted that shared data are being used intensively as a messageboard, and write-back when the bus snooping indicates that few data areshared. A cache line flush or invalidate is the “failure” that signalsthat execution must revert to a higher-cost policy, while a successfulwrite in a lower-cost policy is a “success” that allows continued use ofthe lower-cost policy. The adaptation might be managed on the basis ofaddress ranges, with a record of success and failure maintained for thedistinct address ranges. The switch between mode can be managed by anumber of techniques. For instance, a counter might count the number ofsuccessive memory accesses that would have been more-efficiently handledif the cache were in another mode. When that counter reaches a thresholdvalue, the cache would be switched into the other mode. Or, a timermight set the cache into a more-optimistic mode, and an access thatviolates the assumption of optimism would set the cache into aless-optimistic mode.

The opportunistic policy might be used in branch prediction, cacheprefetch or cache enabling. For instance, cache prefetching might beoperative for as long as prefetching is successful. Or, a particularLOAD instruction in a loop may be identified as a candidate for cacheprefetching, for as long as the prefetch continues successfully. Whenthe prefetch fails, prefetching is disabled.

A multiprocessor cache might cache certain data, on optimisticassumptions, and then mark the data non-cacheable when inter-processorcache trashing shows that caching of these data is unprofitable.

Opportunistic policies might be useful in memory disambiguation inobject-oriented memory systems. For instance, a compiler might generatetwo alternate codings for a source construct, one assuming that twoobjects are disjoint, one assuming overlap. The optimistic disjoint codewould be used for as long as the optimistic assumption held, thencontrol would revert to the pessimistic code.

VII. Validating and Invalidating Translated Instructions

The TAXi system is analogous to a complex cache—the profile data andTAXi code are kept current with the pages of X86 instruction text, andmust be invalidated when the X86 instruction text is modified. There aretwo possible sources for modifications to the X86 instruction text:memory writes by the CPU, and writes from DMA devices. Writes from theCPU are protected by the XP protected bit 184, 186, discussed at sectionI.F, supra, and validity checks in PIPM 602, as discussed in sectionsVI.C and VI.D, supra. This section VII discusses protection of thecached information against modification of the X86 instruction text byDMA writes.

Referring to FIG. 7 a, DMU 700 (the DMA Monitoring Unit) monitors DMAwrites to ASI Zero (address space zero, “well-behaved” non-I/O space) inorder to provide a condensed trace of modification of page frames. DMU700 performs this monitoring without imposing excessive overhead. DMU700 is implemented as an I/O device in the I/O gateway, instead ofdirectly on the main processor bus (the G-bus). This gives DMU 700visibility to detect all non-processor updates of X86 code pages inphysical memory (except for those initiated by the processor itself,which are masked by the behavior of a write-back cache).

A. A Simplified DMU Model

A simple DMU provides modified page frame (MPF) bit for each physicalpage frame in the system. An MPF bit of Zero indicates that nomodification has occurred, and if a DMA transfer were to write into thecorresponding page frame then a modification event would need to bereported against that page frame. An MPF bit of One indicates that DMAwrites to the corresponding page frame should pass unreported.

This simple DMU is initialized by Zeroing all MPF bits. Then, for everyDMA write, the relevant MPF bit is checked. If that MPF bit was alreadyOne, no further processing occurs. If the MPF bit is still Zero, then itis set to One, and the identity of the modified page frame is reported,for instance by creating an entry in a FIFO. Once a page frame's MPF bitbecomes One, and the modification is reported, no amount of additionalDMA writing to that page frame will produce another modification report.

This simple DMU provides tremendous condensation in the reporting ofpage modifications; in fact, it generates a provably minimal number ofmodification reports. The proof follows from the fact that DMU 700itself never Zeros any MPF bits—it only sets them to One. The number ofmodification reports possible is bounded by the number of MPF bits, orequivalently, the number of page frames. Because most DMA writes are tothe buffer pages for “data” I/O, and the important writes to bemonitored are to pages of X86 instruction text, which are written lessoften, this behavior reduces overhead while preserving correct behavior.

So long as a page frame's MPF bit remains Zero, the TAXi system isassured that no DMA modification has occurred since that MPF bit waslast cleared to Zero. Thus, whenever profiler 400 is about to profile anX86 page, generate a TAXi translation, execute a TAXi translation (theoperations that cache information about the page or use cachedinformation), that page's MPF bit is Zeroed, and any queues or FIFO'sthat might contain pending modification reports are flushed. Now profileor translation information from the page may be encached. Whenever amodification of the page frame is reported, any encached informationabout the page is discarded. Once the cached information is purged, thenthe MPF bit for the page can be reset to Zero, and information about thepage may again be cached.

B. Overview of a Design That Uses Less Memory

While the simple design described in section VII.A, supra, would executecorrectly and would impose little interrupt overhead, it might consumetoo much memory. On a system with 28 bits of physical address space and4 KB page frames there are 65K page frames. This translates into 8 KB(or 256 256-bit cache lines) worth of storage just to hold the MPF bits.Those bits could be stored in memory but then, since a DMA read of sucha memory based structure in response to every DMA write cycle would beunacceptable, DMU 700 would have to include some kind of cachingmechanism.

The design described in this section is very similar to the simple modelof section VII.A. In the embodiment discussed below, small, regular,naturally-aligned slices of the full MPF array are instantiated asneeded, to monitor corresponding ranges of the physical address space.This design monitors only a subset of the entire physical address spaceat any given moment. When idle monitoring resources are reclaimed tomonitor different physical addresses, this design for DMU 700 makes theconservative assumption that no page frame within the range that isabout to be monitored has had a modification reported against it. Thisconservative assumption induces redundant reports of modification topage frames for which modifications had already been reported at somepoint in the past.

C. Sector Monitoring Registers

Referring to FIG. 7 a, DMU 700 has several Sector Monitoring Registers(SMR) 707, typically four to eight. In the example embodiment discussedhere, it is assumed that there are four SMR's 707 in the SMR file. EachSMR 707 monitors a sector, a naturally-aligned region of a power of 2number of page frames. In the embodiment of FIG. 7 a, a sector is anaturally-aligned 128 KB range of the G-bus physical memory addressspace, or equivalently, a naturally-aligned group of thirty-two 4 KBpage frames. Each SMR 707 consists of a content addressable sector CAM(content-addressable memory, analogous to a TLB address tag) 708, anarray of MPF (Modified Page Frame) bits 710, an Active bit 711, and asmall amount of logic. Sector CAM address tag 708 is eleven bits for a28-bit physical address space (28, less 12 bits of byte addresses withina page, less 5 bits for the 32 pages per sector—see FIG. 7 a). MPF array710 has 32 bits, one bit for each page frame in the sector. Each MPFarray is essentially a 32-bit slice of the large MPF bit array describedin section VII.A. (In order to maximize the opportunity to use large DMAtransfers, modern operating systems tend to keep sequential virtualpages in sequential clusters in physical memory, so clustering of pagesin an MPF array 710 offers much of the advantage of distinct MPF bits atlower address-tag matching overhead.) SMR.Active bit 711 is set to Oneif there was at least one Zero-to-One transition of an MPF bit 710 sincethe last time the SMR 707 was read. Thus, an SMR 707 is Active 711 whenit contains at least one MPF bit 710 that has transitioned from Zero toOne since the last time the SMR 707 was read out via DMU_Status register720 (see section VII.G, infra.) DMU 700 will never reassign an activeSMR 707 to monitor a different sector.

A DMU interrupt is asserted when one or more page frames have beenmodified, that is, when an MPF bit transitions from a Zero to a One. Thehandler for the DMU interrupt identifies the modified page frame(s). Ifthe modified page is X86 text, then any translated TAXi code, and anyprofile information describing the page, are purged, and thecorresponding PIPM entry 640 is released.

Referring to FIG. 7 a, the physical address space is divided into 4Kpages in the conventional manner. The pages are grouped into contiguousblocks called sectors. In the embodiment of FIG. 7 a, thirty-twocontiguous, naturally-aligned pages form one sector. In this embodiment,which allows for a maximum of 256 MB of physical memory, bits <27:17>702 designate the sector. In other embodiments, more physical memory canbe accommodated by extending the number of bits 702 to designate asector. Bits <16:12> 704 designate the page number within a sector 702.Bits <11:00> designate a byte within a page.

D. Interface and Status Register

FIG. 7 b illustrates the DMU interface. Writing to DMU_Command register790 provides the sector address 702 and page address 704 (which in turn,is the bit address for the page's MPF bit within the SMR 707) and a DMU700 command from the G-bus data. The low six bits of a datum are writtento DMU_Command register 790 designates the command. The six bits of thecommand portion are designated D, E, R, A, M and X 791 a-796 a. (Themeaning of these bits is discussed in detail in section VII.H, infra.)When a DMA device issues a write to memory, the command value is D, E, Requal to Zero and A, M, X equal to One. From the D, E, A, M, X and Rsignals, several predicates are derived. Enable signal 714 means thatthe DMU is currently enabled. Allocate signal 715 is asserted on a bustransaction in which memory is written from a DMA device, and thus anSMR register must match, or be newly allocated to track the write. MPFmodify signal 716 is asserted when the setting of the command bitsspecifies that the contents of an MPF bit 710 is to be written. MPF datasignal 717 carries a datum to be written to an MPF bit 710 when MPFmodify 716 is asserted. Reset signal 718 is asserted when the R resetcommand 794 a is asserted on the bus. Read signal 719 is asserted as adistinct line of the G-bus FIG. 7 b also shows the Enable and Overrunflip-flops and the interrupt generation logic. The meanings of the sixcommand bits 791 a-796 a are discussed in more detail infra, inconnection with FIGS. 7 i and 7 j.

When DMU 700 is enabled 714, DMU 700 requests an interrupt anytime thereis at least one SMR 707 whose SMR.Active bit 711 is One or whenever theDMU Overrun flag 728 is set. The value of the active 711 SMR 707 isexposed in DMU_Status register 720.

Referring to FIG. 7 c, DMU_Status register 720 is 64 bits wide. Thesector bits are located at their natural position, bits <30:17>, withina physical address, allowing for implementations with up to 2 GB ofphysical memory. The DMU_Status.Active bit 723 (bit <31>) is One when anactive 711 SMR 707 is selected and Zero when all SMR's 707 are inactive.The least significant Modified Page Frame bit (SMR<32>) 724 correspondsto the page frame at the lowest address within a sector. Successive MPFbits 710 correspond to successively higher page frames. WhenDMU_Status.Active bit 723 is One, then the value of SMR# field 725(SMR<02:00>) identifies the SMR 707 being returned. WhenDMU_Status.Active bit 723 is Zero, the Modified Page Frame bits 710,Sector bits 722 and SMR# 725 are all Zero.

The Enable bit 727 and Overrun bit 728 are not actually part of anyspecific SMR 707. Rather they summarize the overall state of DMU 700 andall SMR's 707. Monitoring of DMA activity occurs only when DMU Enable714 is set (DMU_Status.Enable 727 reflects the value of DMU Enable 714,which in turn is set by writing to DMU_Command.Enable 795, see FIGS. 7 iand 7 j). Overrun bit 728 is provided at the time that an SMR 707 isread out, to allow recognition of cases when DMU 700 has shut down inresponse to a catastrophic overrun condition. The position of Overrunbit 728 as bit <15> (the sign bit of a 16-bit segment of DMU_Statusregister 720) simplifies testing it. DMU_Status register 720 isdescribed further in section VII.G in connection with FIG. 7 h.

E. Operation

Referring to FIG. 7 d, the following steps occur on each DMA writetransaction. In step 730, DMU Enable 714, 727 is tested. If the DMU isdisabled, no further processing occurs. In step 731, the target physicaladdress of the DMA bus transaction is captured into DMU_Command register790. Bits <27:17> 702 of the target address are captured as the sectornumber, and bits <17:12> 704 are captured as the page number index intoan SMR of 32 MPF bits 710, as shown in FIG. 7 a. In step 740, SMR sectorCAM address tags 708 are searched associatively using the sector number.(This search will be elaborated further in the discussion of FIG. 7 e insection VII.F.) If the search succeeds (arrow 732), control skipsforward to step 737. If there is no match with any sector CAM addresstag 708 (arrow 733), in step 750, an inactive SMR 707 (one whoseSMR.Active bit 711 is Zero) is allocated. (Allocation is discussedfurther in connection with FIG. 7 f). If no inactive SMR 707 isavailable, then a catastrophic overflow has occurred, and in step 734,DMU Overrun 728 is set. On an overrun 728, TAXi processing is aborted,and all translated code segments are purged (it is known that the DMAwrite that caused the overrun 728 may have overwritten a page of X86code that had corresponding TAXi code, but the identity of that pagecannot be identified, so all pages of TAXi code are considered suspect).Once the TAXi “cache” is purged, TAXi operation can resume. If aninactive SMR 707 can be located (arrow 735), then in step 736 within theallocated SMR 707, all MPF bits 710 are Zeroed. Sector CAM address tag708 of the allocated SMR 707 is loaded with the search key, sectornumber 702. With SMR 707 thus allocated and set, it now satisfies theassociative search criteria, so control flows to step 737 as though thesearch of step 740 had succeeded.

In step 737, within matching SMR 707, the MPF bit 710 corresponding tothe modified page frame is tested. If the MPF bit 710 is already set toOne (arrow 738), then no further processing is necessary. Otherwise(arrow 739), in step 760, 778, the appropriate MPF bit 710 and theSMR.Active bit 711 are set to One (Active bit 711 may already be set).

F. Circuitry

Referring to FIG. 7 e, sector match hardware 740 performs theassociative search of the sector CAM address tags 708 to determinewhether the sector 702 of the current DMA write transaction already hasan SMR 707 associated. Sector compare circuit 741 simultaneouslycompares the sector address 702 from DMU_Command register 790 with eachof the four CAM address tag values 708 of the four SMR's 707 in the SMRfile. Sector compare circuit 741 puts the result of this comparison onfour bit bus 742: each line of bus 742 is set to One if thecorresponding SMR address tag 708 matches the bus sector address 702. Ifany one of the four lines of bus 742 is One, then there was a match; ORgate 743 OR's together the four lines to determine whether a matchoccurred. Since the sector value in an inactive SMR 707 is undefined,more than one SMR 707 could match the incoming sector address 702. Unarypriority function 745 resolves this ambiguity by deterministicallyselecting at most one of the four asserted lines from bus 742. Thus, the“matched SMR” 4-bit bus 746 will always have at most one line set toOne.

Referring to FIG. 7 f, SMR allocation hardware 750 allocates one of theinactive SMR's 707 out of the pool for writing into when none of thecurrent SMRs' address tags 708 match sector address 702. Inactive SMRfunction 751 selects one of the inactive SMRs 707 (those whoseSMR.Active bits 711 are Zero) if one is available. If the current bustransaction writes into a memory sector 702 that has no SMR 707 with acorresponding address tag 708 (indicated by matched 744 being Zero), andno SMR 707 is inactive 711 to accept the write (indicated by Allocate715 being One), then the Overrun 728 condition has occurred. Otherwise,the SMR-to-write mask 753 (a four bit bus, with the one line assertedcorresponding to the SMR register to be written) is generated from theSMR-to-read mask 787 (a four bit bus, with the one line assertedcorresponding to the SMR register to be read), the matched SMR mask 746(a four bit bus, with the one line asserted corresponding to the SMRregister whose CAM sector address tag matches the bus address sector702) and the inactive SMR mask 754 (the complement of the fourSMR.Active bits 711 of the four SMR registers 707).

After sector match circuitry 740 or allocation circuitry 750 hasselected an SMR 707, MPF update logic 760, 772, 778 updates theappropriate MPF bits 710 and SMR.Allocate bits 711 in the selected SMR707. (Part of MPF update logic 760, the portions 772, 778 that updatethe SMR address tags 708 and SMR.Active bits 711, are shown in FIGS. 7 eand 7 f and omitted from FIG. 7 g.) The MPF bits 710 to modify areselected by MUX 761, whose select is the SMR-to-write mask 753. If thesector address 702 matched 744 none of the address tags 708 of any SMR707, then this is a newly-allocated, empty SMR 707; AND gate 762generates all Zeros so that all MPF bits 710 of the new SMR 707 will beZeroed. MPF bit update function 763 generates a new 32-bit value 764 forthe MPF portion 710 of the selected SMR 707. The inputs to MPF bitupdate function 763 are the 5-bit page address 704 within the sector 702(these five bits select one of the 32=2⁵ bits of MPF), the old contentsof the MPF 710, and the MPF modify signal 716. The outputs 764, 766 ofMPF bit update function 763 are chosen according to table 765. If theold MPF bit 710 value was Zero and the new bit 710 value is One, then aZero-to-One MPF transition 766 signal is asserted. The 32 bits of newMPF value 764 are OR'ed together to generate MPF-all-Zeros signal 767.Write logic 768 determines which MPF bit 710 to update, using as inputsthe Reset 718, Allocate 715, matched 744, MPF modify 716, andSMR-to-write 753 signals. The outputs 770, 771 of write logic 768 arechosen according to table 769. If column 770 is a One, then the MPF bits710 of the SMR 707 selected by SMR-to-write mask 753 are written with32-bit value 764. If column 771 is a One, then the other SMR's 707 arewritten as well. Thus, the last line of table 769 indicates that a Reset718 writes the all-Zeros value generated by AND gate 762 to all MPFregisters 710.

Referring again to FIG. 7 f, write logic 772 determines a new SMR.Activebit 711 value to write according to table 773. The inputs to write logic772 are Read 719, MPF all Zero's signal 767 and Zero-to-One MPFtransition signal 766. Column 774 tells whether to write the SMR.Activebit 711 of the SMR 707 selected be SMR-to-write 753 when the data inputsto write logic 772 match columns 719, 767, 766. If column 774 is One,then column 775 tells the data value to write into that SMR.Active bit711. Similarly, column 776 tells whether or not to write the SMR.Activebits 711 of the unselected SMR registers, and column 777 tells the datumvalue to write.

Referring again to FIG. 7 e, the sector tag 708 of a newly-allocated 750SMR 707 is written as determined by write logic 778 (write logic 778 isintertwined with write logic 768, 772, and is presented here simply forexpository reasons). Write logic 778 accepts as input Allocate signal715 and matched signal 744, and computes its outputs according to table779. As indicated by the center row of the table, when an empty SMR isallocated by allocate logic 750 (the new allocation is indicated byAllocate 715 being One and the emptiness is indicated by matched 744being Zero), then the sector address tag 708 of SMR indicated bySMR-to-write mask 753 is written. Else, as indicated by the top andbottom rows of table 779, no SMR 707 is written.

FIGS. 7 d-7 g are merely representative of one embodiment. Knowntechniques for associative cache or TLB address tag matching, cache lineplacement policies, and inter-processor modified and dirty bits aregenerally applicable to managing SMR's 707. (One difference should benoted. In a software-managed TLB, on a TLB miss, the PTE in memory isupdated, and then the PTE is copied into the TLB. Thus, there is alwaysa reliable backing copy of the TLB. In the DMU design presented here,there is no backing memory for the SMR registers 707.)

In an alternative embodiment, in FIG. 7 d, an additional step isperformed in parallel with step 740: TLB 116 is consulted to determinethe ISA bit 182 and XP bit 184, 186 for the page being written. Unlessthe ISA bit 182 and XP bit 184, 186 are both One (indicating a page ofprotected X86 code), the entire rest of the DMU can be bypassed. The DMUexists only to track the validity of the TAXi code “cache” over theoriginal X86 code, and if no such TAXi code can exist, then theremaining functions can be omitted.

Whenever an MPF bit undergoes a Zero-to-One transition, that is, whenone or more page frames have been modified, a DMU interrupt is raised.The handler for the DMU interrupt identifies the modified page frame(s)by retrieving the state of all the active 711 SMR's 707. The search foran active SMR 707 is performed in hardware, as described next.

G. DMU_Status Register

Referring to FIG. 7 h in conjunction with FIG. 7 c, DMU_Status register720 is a 64-bit register on the G-bus. It is the only source of DMUinformation used in normal TAXi operation. If DMU Enable 714 (reflectedin DMU_Status.Enable 727, bit <14> of DMU_Status register 720) is Zero,then all reads of DMU_Status register 720 will return a result that isentirely Zero. Such a read does not re-enable DMU 700; DMU re-enablementis only accomplished by reinitialization. If DMU Enable 714 is One andno SMRs 707 are active 711, then all reads of DMU_Status 720 will returna result that is entirely Zero except for a One in DMU_Status.Enable bit727. If DMU Enable 714 is One and there is at least one SMR 707 whoseSMR.Active bit 711 is One, then reading DMU_Status 720 will return asnapshot of one of the active 711 SMRs 707. This snapshot will have atleast one MPF bit 710 set, DMU_Status.Active bit 723 set (reflectingSMR.Active bit 711 of the SMR 707) and DMU_Status.Enable bit 727 set.Reading the DMU_Status register 720 has the side effect of ZeroingSMR.Active bit 711 of the SMR 707 currently reflected in the DMU_Statusregister 720, leaving the SMR 707 ready for reallocation 750, but theaddress tag 708 and MPF bits 710 are left intact. Thus, further DMAwrites into the same page will not induce a new Zero-to-One transitionreducing the interrupt overhead induced by intensive I/O to I/O buffers.That SMR 707 will become active 711 again only if it gets reallocated750 or if a DMA write occurs within the sector 702 that it monitors to apage frame whose MPF bit 710 is Zero. Similarly, a DMU interrupt willonly be raised for that page if the MPF bit for the page is explicitlycleared (using a command where the M command bit is One, and all othercommand bits are Zero, see the commands discussed in section VII.H).

DMU_Status register 720 is driven by inputs from the file of SMR's 707.The SMR select function 782 chooses an SMR 707 whose SMR.Active bit 711is One. The selection 783 of the active SMR is used to select 784 thecorresponding sector tag 708 and MPF bit 710 portions of the selectedSMR 707. When there is no active 711 SMR 707 (computed by OR gate 785),or the DMU is disabled 714, then AND gates 786 ensure that all outputsare Zero. The selection 783 is gated by an AND gate to generateSMR-to-read signal 787, which is used in FIG. 7 f to select one SMRregister to be read.

Returning to the operation of the interrupt handler software, the act ofreading DMU_Status register 720 is taken by DMU 700 as an implicitacknowledgment of the notification and hence a sign that the SMR(s) 707involved can be reassigned. The DMU interrupt handler checks ISA bit180, 182 and XP bit 184, 186 for the page to see whether the pagewritten by the DMA write is a protected X86 page (this can be done inhardware before raising the interrupt, or in software). If the page is aprotected X86 page, then the interrupt handler consults PIPM 602 to seewhether any translated TAXi code exists corresponding to the modifiedpage, and whether any profile information 430, 440 exists describing themodified page. If TAXi code is found, then it is released, and PIPM 602is updated to reflect the release. If profile information is found, thenit is released.

The DMU interrupt has higher priority than the probe exception, so thata probe will not transfer control to a page that has recently beeninvalidated.

H. DMU_Command Register

Referring to FIGS. 7 i, 7 j and Table 5 in conjunction with FIG. 7 b,software controls DMU 700 through the DMU_Command register 790. Bits<05:00> 791-796 control initializing DMU 700, response after an overrun,re-enabling reporting of modifications to a page frame for which amodification might already have been reported, and simulating DMAtraffic. The functions of the bits 791 are summarized in the followingtable 5.

TABLE 5 command bit bit position Meaning D 5 Disable monitoring of DMAwrites by Zeroing the DMU enable flag E 4 Enable monitoring of DMAwrites by setting the DMU Enable flag to One R 3 Reset all SMR's: Zeroall A and MPF bits and Zero the DMU overrun flag A 2 Allocate aninactive SMR on a failed search M 1 Allow MPF modifications X 0 New MPFbit value to record on successful search or allocation

D command bit 796 a, 796 b, 796 c Zeros DMU Enable 714, 727, therebydisabling any further changes to the SMRs 707 due to DMA traffic. If DMUEnable 714, 727 is already Zero, D bit 796 has no effect.

E enable command bit 795 a, 795 b, 795 c sets DMU Enable 714, 727 toOne, thereby enabling monitoring of future DMA traffic and DMAinterrupts. If DMU Enable 714, 727 is already set, E bit 795 has noeffect.

R command bit 794 a, 794 b, 794 c resets DMU 700. It does this byZeroing the SMR.Active bit 711 and all MPF bits 710 in every SMR 707 andalso Zeroing DMU Overrun flag 728. The R command bit 794 has no effecton the values in the sector address CAM address tags 708. The R command794 takes precedence over the A, M and X commands 793, 792, 791, andresets DMU 700 whether or not DMU 700 is enabled.

The high order bits (bits <27:12>) 797 of DMU_Command register 790identify a page frame. Whenever a write occurs to DMU_Command register790, the page frame address 797 is presented to the SMR sector CAMaddress tags 708. The A, M and X command bits 793, 792, 791 control whathappens under various conditions:

-   1. If the sector match hardware (740 of FIG. 7 e) fails to find a    match 744, and A command bit 793 is Zero, then do nothing. If there    is no match 744, and A command bit 793 is One, then normal    allocation 750 is performed, as described in connection with FIGS. 7    d and 7 f. (Recall that normal allocation 750 can lead to an overrun    condition 728 and hence to a DMU interrupt).-   2. If either sector matching 740 or sector allocation 750 succeeds,    then the M and X command bits 792, 791 define three possible actions    according to table 6:

TABLE 6 M X Action 0 — Inhibit modification of the MPF bit 1 0 Zero thecorresponding MPF bit 1 1 set the corresponding MPF bit to One

Writing a page frame address 702, 704, 797 to DMU_Command register 790with the M command bit 792 set to One and the rest of the command bits791, 793-796 to Zero searches 740 the sector CAM address tags 708 for amatch. If a match 744 is found, the corresponding MPF bit 710 is Zeroed(because M bit 792 is One and X bit 791 is Zero, matching the secondline of table 6). This is how TAXi enables monitoring of a page that isabout to be turned from a page whose ISA bit 180, 182 is One and XP bit184, 186 is Zero (unprotected X86 code) into a page whose XP bit 184,186 is One (protected X86 code). If the MPF bit 710 that is cleared bysuch a command was the only MPF bit 710 set in the SMR 707, then the SMR707 reverts to inactive 711 and can be reallocated 750 to monitor adifferent sector. SMR.Active bit 711 is only affected by an MPFtransition from Zero to One, or a transition of the last MPF bit fromOne to Zero. Otherwise, SMR.Active bit 711 is unaffected by changes tothe MPF bits 710.

It is software's responsibility never to enable DMU 700 until the sectorCAM address tags 708 contain mutually distinct values. Once an overrun728 occurs this condition is no longer assured. Hence the safestresponse to an overrun is reinitialization:

-   -   DMU_Command=D+R //Disable DMU, reset SMRs 707    -   for (i=0, i<#SMRs, i++){ //Initialize all SMRs 707        -   //Initialize each SMR 707 to a distinct address, by        -   //allocating a new SMR (A+M command bits) with        -   //sector “j” (<<17) and page zero (1<<12) within the sector        -   DMU_Command=(i<<17)+(1<<12)+A+M    -   }    -   DMU_Command=E+R //Enable DMU, free all SMRs        If not properly initialized the behavior of DMU 700 is        undefined, guaranteed only not to harm the chip nor to introduce        any security holes.

In an alternative embodiment, DMU 700 is more closely integrated withTLB 116. In these embodiments, DMU 700 has access to ISA bit 182 and XPbit 186 (see section I.F, supra), and only raises an interrupt when aprotected X86 page is written, or if the written page has no entry inTLB 116.

VIII. Managing Out-of-order Effects

Requiring all memory references (memory loads, memory stores, andinstruction fetches) to be in-order and unoptimized limits the speed-upachievable by TAXi. Often the only barrier to optimization is knowingwhether or not a load references well-behaved memory or someun-memory-like object. Recovering the original order of side effects,and preserving perfect X86 behavior, in spite of reordering andoptimization by the TAXi translator, is discussed in section VIII.

A. Ensuring In-order Handling of Events Reordered by OptimizedTranslation

Binary translator 124 is allowed to use code optimization techniquesthat reorder memory read instructions, floating-point instructions,integer divides, and other instructions that may generate exceptions orother side effects, in spite of the fact that the TAXi execution modelof perfect emulation of the X86 maintains the order of side-effects.(“Side-effects” are permanent state changes, such as memory writes,exceptions that the X86/Windows architecture exposes to the applicationprogram, etc. Thus, a memory write and a divide-by-zero are eachside-effects whose order is preserved relative to other side effects.)For instance, all memory references (memory reads, memory writes, andinstruction fetches) are assumed to be “well-behaved,” free of bothexceptions and hidden side-effects. All side-effects are kept orderedrelative to each other. Correct execution is then ensured by catchingany violations of these optimistic assumptions before any side-effect isirreversibly committed.

When profile information (see section V) tells TAXi translator 124 thata memory read can have a side-effect, for instance a read to I/O space(see section VIII.B, infra), then the X86 code is translated using moreconservative assumptions, assumptions that disallow memory referencesfrom being optimized to eliminate redundant loads, or to be reordered.This conservative code is annotated as having been generated underconservative assumptions. When conservative code accesses I/O space, thememory reference is allowed to complete, because the annotation assuresthe run-time environment that the code was generated with no optimisticassumptions. References to well-behaved memory from conservative codecomplete normally, simply at the cost of the foregone optimization.

Conversely, if no I/O space reference appears in the profile, then theTAXi code will be optimized under the optimistic assumption that allreferences are to well-behaved (that is, ASI Zero) memory—memory readsmay be reordered or eliminated. The code is annotated to record theoptimistic assumptions. All references to well-behaved memory completenormally, regardless of the value of the annotation. When optimisticTAXi code is running, and a memory reference violates the optimisticassumption by referencing I/O space (ASI not Zero) from optimistic code,then the reference is aborted by a TAXi I/O exception. In TAXi codereferences to I/O space are allowed to complete only if the code isannotated as following conservative assumptions. When a TAXi I/Oexception occurs, the exception handler will force execution to resumein the converter.

When TAXi translator 124 generates native code, it may make theoptimistic assumption that all memory references are to safe,well-behaved (ASI Zero) memory and can be optimized: e.g., that loadscan be moved ahead of stores, if it can be proved that the memorylocations don't overlap with each other, that memory reads can bereordered with respect to each other and with respect to instructionsthat do have side-effects, and that redundant loads from the samelocation, with no intervening store, can be merged together(CSE'd—common sub-expression). TAXi translator 124 preserves all memorywrites—memory writes are neither removed by optimization nor reorderedrelative to each other. However, references to I/O space, even merereads, may have unknown side-effects (e.g., successive reads may returndistinct values, and/or trigger separate side effects in an I/Odevice—recall, for instance from section VII.G, that a read of theDMU_Status register 720 invokes a state change in DMU 700, so the nextread of DMU_Status 720 will give a different result).

TAXi translator 124 relies on the safety net to protect references tonon-well-behaved I/O space, that is, to intervene when the well-behavedtranslate-time optimistic assumption is violated at run time. The TAXisystem records a static property of each memory reference, annotatingwhether that memory reference (specifically, a load) is somehowoptimized.

TAXi translator 124 conveys to the hardware whether a memory referenceinvolves optimistic assumptions or not. Those references that involve nooptimistic assumptions are always allowed to complete. Those that doinvolve the optimistic assumption that the target is well-behaved memorywill have this assumption verified on every execution and are aborted ifthe assumption cannot be guaranteed correct.

In one embodiment, one bit of each load or store instruction (or one bitof each memory operand descriptor in an instruction, if a singleinstruction makes multiple loads or stores) is reserved to annotatewhether or not that particular load or store is optimized.

The following embodiment eliminates the need to dedicate one instructionopcode bit for this purpose.

The optimistic/conservative annotation is recorded in the “TAXiOptimized Load” bit 810 of a segment descriptor.

Because every X86 load is based off a segment register (the reference toa segment register may be explicitly encoded in the load operation, orit may be implicit in the instruction definition), and every segment hasa segment descriptor, the segment register is a useful place to annotatethe optimized property, and to monitor memory references. As each X86load operation is decoded into micro-ops to send down the Tapestrypipeline, the segment register is explicitly materialized into themicro-op.

When TAXi code is running (that is, when PSW.TAXi_Active 198 isasserted), and in TAXi translated code a load occurs in-order withrespect to other memory references, then the effect will be identical tothe original X86 instruction stream irrespective of the nature of memoryreferenced by that load. When memory references are not reordered, it ispreferable that a TAXi Optimized Load 810 Zero segment be used, so thatno exceptions will be raised.

Referring to FIG. 8 a, a Tapestry segment register 800 encodes asuperset of the functions encoded in an X86 segment descriptor, and addsa few bits of additional functionality. Bit <61> of Tapestry segmentregister 800 is the “TAXi Optimized Load bit” 810. (The segmentdescriptor TAXi Optimized Load bit 810 is distinct from theTAXi_Control.tio bit 820.). When the segment descriptor TAXi OptimizedLoad bit 810 is One, all memory references off of this segment registerare viewed as having been optimized under the optimistic assumptions. Ifa memory reference goes through a segment descriptor whose TAXiOptimized Load bit 810 is One, and the reference resolves tonon-well-behaved memory (D-TLB.ASI, address space ID, not equal toZero), and PSW.TAXi_Active 198 is true, then a TAXi I/O exception israised. The handler for the TAXi I/O exception rolls the executioncontext back to the last safety net checkpoint and restarts execution inconverter 136, where the original unoptimized X86 instructions will beexecuted to perform the memory references in their original form andorder.

The X86 has six architecturally-accessible segment descriptors; Tapestrymodels these six for the use of converter 136, and provides anadditional ten segment descriptors 800 accessible to native Tapestrycode and TAXi code. The six X86-visible registers are managed byexception handlers in emulator 316—when X86 code reads or writes one ofthe segment descriptors 800, the exception handler intervenes to performboth the X86-architecturally-defined management and the management ofthe Tapestry extended functions. Converter 136 and emulator 316 ignorethe value of the segment descriptor TAXi Optimized Load bits 810; duringexecution of X86 code in converter 136, the value of bits 810 could berandom. Nonetheless, converter 136 maintains bits 820 for the benefit ofTAXi—in these six segment descriptors, the value of the segmentdescriptor TAXi Optimized Load bit 810 always matches Taxi_Control.tio(820 of FIG. 4 g).

The hardware format of a Tapestry segment register 800 differs from thearchitecturally-specified format of an X86 segment descriptor. SpecialX86-to-Tapestry hardware is provided to translate from one form to theother. When X86 code writes a segment descriptor value into a segmentregister, emulator 316 takes the segment descriptor value and writes itinto a special X86-to-Tapestry conversion register. Hardware behind thespecial conversion register performs shifting and masking to convertfrom the X86 form to Tapestry form, copying the X86 segment descriptorbits into different bit positions, and gathering the Tapestry extendedbits from elsewhere in the machine. In particular, the cloned segmentdescriptor's TAXi Optimized Load bit 810 is copied from TAXi_Control.tio820. Emulator 316 then reads the special conversion register, and thatvalue is written into one of the Tapestry segment registers 800.

At any particular software release, the value of TAXi_Control.tio 820will always be set to the same value, and the TAXi translator 124 willrely on that value in translating X86 code.

Referring to FIGS. 8 b and 8 c, the segment descriptor TAXi OptimizedLoad bit 810 is managed by the TAXi translator 124, as follows.

For the six segment registers visible to the X86, the default value ofTAXi Optimized Load 810 is programmable at the discretion of theimplementer. Recall that TAXi Optimized Load 810 is ignored by converter136. Hence, each time the converter 136 loads a segment descriptorregister (a complex operation that in reality is performed in emulator316), TAXi Optimized Load can be set arbitrarily. The conversion of X86format segment descriptor values into Tapestry internal segmentdescriptor format is performed by hardware. This hardware must providesome value to TAXi Optimized Load. Rather than hardwire the value, theTapestry system makes the value of the TAXi Optimized Load bit 810programmable via TAXi_Control.tio 820.

At system boot TAXi_Control.tio 820 is initialized to reflect the formof loads most likely to be emitted by the current TAXi translator. Iftranslator 124 is not especially mature and rarely or never optimizesloads, then TAXi_Control.tio 820 is initialized to Zero. This means thatthe segment descriptors mapped to the six architecturally visible X86segment registers will always have TAXi Optimized Load 810 Zero. Thencode to clone the descriptor and set TAXi Optimized Load need only begenerated in the prolog when a optimized load is actually generated.

The default registers will all be in one state, chosen to be the morecommon case so that those registers can be the defaults for use by TAXi.When TAXi wants the other semantics, the descriptor cloning at thebeginning of the TAXi segment will copy the descriptor used by converter136, using a copy of TAXi_Control.tio 820 into the new segmentdescriptor's TAXi Optimized Load bit 810. The opposite sense for bit 810will be explicitly set by software. For instance, if the default senseof the segment descriptor is TAXi Optimized Load of Zero (the moreoptimistic assumption that allows optimization), then all optimizedmemory references must go through a segment descriptor that has TAXiOptimized Load bit 810 set to One, a new descriptor cloned by the TAXicode. This cloned descriptor will give us all the other descriptorexceptions, the segment limits, all the other effects will be exactlythe same, with the additional function of safety-net checking for loads.

Referring to FIG. 8 b, as the TAXi optimizer 124 translates the binary,it keeps track of which memory load operations are optimized, and whichsegment descriptors are referenced through loads that counter thedefault optimization assumption. FIG. 8 b shows the actions taken in anear-to-last pass of translator 124, after all optimization has beencompleted, but before final emission of the new Tapestry binary. Theupper half 840 of FIG. 8 b covers the case of relatively early releasesof TAXi optimizer 124, when optimization that reorders the side-effectsis the exception rather than the rule. Lower half 850 reflects the latercase, when optimization is more common, in which case the value of asegment's TAXi Optimized Load 810 would default to One, which in turn iscontrolled by setting TAXi_Control.tio 820 to One. For memory referencesthat are reordered, commoned, or otherwise optimized on the optimisticassumption that only well-behaved, side-effect-free memory will beaddressed (steps 841, 851), TAXi translator 124 forces the memoryreferences to go through a segment descriptor whose TAXi Optimized Load810 value is One (steps 843, 852). If the assumption is violated, thatis, if at run time the memory reference through a TAXi Optimized Load810 One segment is found to access I/O space, then that memory referencewill raise a TAXi I/O exception, and execution of the translated codewill be aborted into the safety net of converter 136. If the TAXitranslator 124 is willing to adopt conservative assumptions and notforgo opportunities to optimize this memory reference (for instance, ifthe profile indicates that this load referenced I/O space, as discussedin section VIII.B) (steps 844, 853), then the memory reference can gothrough a segment descriptor whose TAXi Optimized Load 810 bit is Zero(step 845, 855), thus guaranteeing that this memory reference willcomplete and never generate a TAXi I/O exception, even if tonon-well-behaved memory.

In steps 842 and 854, TAXi translator records which segment descriptorsare used in a non-default manner. The overhead of a cloning adescriptor, and setting a non-default value of TAXi Optimized Load 810,is only borne when required.

Referring to FIG. 8 c, at the beginning of each translated hot spot,TAXi translator 124 inserts code that creates a cloned copy of any ofthe segment descriptors that were marked by steps 842, 854, as beingused in a non-default way, into one of the ten extra segment descriptors(step 866). This cloned descriptor will be used for some of the memoryreferences made by the translated code, those that match the assumptionembedded in the current release's value of TAXi_Control.tio 820. Theprolog code copies (step 866) the segment descriptor, and sets (step868) the TAXi Optimized Load bit 810 to the sense opposite to the valueof TAXi_Control.tio 820, for use by memory references that assumeopposite to the assumption embedded in the current release's value ofTAXi_Control.tio 820.

TAXi Optimized Load bit 810 has the following run-time behavior.

When converter 136 is running (that is, when PSW.TAXi_Active bit 198 isZero), the TAXi optimized load bit 810 has no effect. Thereforeconverter 136 can issue loads through a segment irrespective of thevalue of the TAXi Optimized Load bit 810. Whatever the value of TAXiOptimized Load bit 810, the converter will be allowed to performarbitrary memory references to arbitrary forms of memory and no TAXioptimized load exception will be induced.

When PSW.TAXi_Active 198 is One, the TAXi Optimized Load bit 810determines whether a load from a non-zero ASI (i.e. memory not known tobe well-behaved) should be allowed to complete (TAXi Optimized Load isZero) or be aborted (TAXi Optimized Load is One). A TAXi I/O exceptionis raised when all three of the following are true:

-   -   1. PSW.TAXi_Active 198 is One    -   2. a memory reference goes through a segment whose TAXi        optimized Load bit 810 is One    -   3. the memory reference touches I/O space, that is, the ASI is        not Zero        Given a mention of an X86 segment in some X86 code, the TAXi        translator will sometimes want to use a descriptor with TAXi        Optimized Load of One and sometimes with TAXi Optimized Load 810        Zero. Given an ability to read and write the descriptor register        file, and one or more spare segment descriptor locations, a        properly configured descriptor can be constructed by reading the        original X86 descriptor location and setting or clearing TAXi        Optimized Load 810 as appropriate.

Consider an example, where the TAXi translator uses optimisticassumptions and CSE's two loads together, so that only one loadinstruction actually exists in the TAXi instruction stream. The loadthat is actually optimized is the later load—but it no longer exists inthe optimized instruction stream. Therefore, the remaining load isannotated, even if that load was not itself reordered relative to otherside effects. When a load actually occurs to I/O space, off a TAXiOptimized Load 810 segment, then execution is rolled back to aninstruction boundary, where all extended Tapestry state is dead. TheTAXi code is abandoned, and the original X86 code is executed inconverter 136. Converter 136 will execute the X86 instructions exactlyas it sees them and it will execute every one of the loads (the X86instruction stream will still be in its original unoptimized form, evenif the TAXi instruction stream was optimized) so that there will be noloads dropped from the stream as emitted by converter 136.

The TAXi I/O fault is recognized before any side effects of theinstruction are committed.

All TAXi code is kept in wired memory. Thus, no page fault can occur infetching an instruction of TAXi code, and any page fault mustnecessarily involve a data reference.

As the TAXi code executes, as it crosses from a region translated fromone page of X86 text to another page, it “touches” (a load without useof the result) the corresponding pages of X86 instruction text. (Thepage boundary crossings of the original X86 instruction text, were notedin the profile using the mechanism discussed in connection with FIGS. 4e and 4 f in section V.D.) This induces page faults in the original X86code, to provide faithful emulation of the execution of the original X86code.

After servicing a TAXi I/O exception in the Tapestry operating system312 and emulator 316, execution is restarted. In a simple embodiment,the X86 is restored to a previous X86 instruction boundary, and therestart is always at an X86 instruction boundary. Thus, if a single X86instruction has two loads, then translator 124 must take one of twostrategies, either (1) neither load can be optimized, or (2) both haveto be annotated as optimized. This avoids a situation in which the firstload is to non-well-behaved memory and is then re-executed if the secondload raises a TAXi I/O exception.

B. Profiling References to Non-well-behaved Memory

Referring again to FIG. 4 b, memory loads that are directed to anythingother than address space ID (ASI) zero are recorded in the executionprofile (see section V, supra) with a profile entry whose event code is1.1100. ASI-non-zero references are typically (and conservativelyassumed to be) directed to I/O space, that is, memory that is notwell-behaved, as discussed in section I.D, supra. This indicationprovides a good heuristic for the TAXi translator 124 to choose betweengenerating aggressive, optimized code and generating conservative,in-order code.

The initial assumption is that all memory reads are directed towell-behaved (address space zero) memory. When converter 136 is running(PSW.ISA indicates X86 mode), and profiler 400 is active(TAXi_State.Profile_Active 482 is One, see section V.E and V.F, infra),load instructions to I/O space (D-TLB.ASI not equal Zero) that completecause a “I/O space load” profile entry to be stored in a register. TheTAXi translator will interpret this profile entry to indicate that theoptimistic assumption does not hold, and that at least this load must betreated under pessimistic assumptions by translator 124, and can bemarked with the “safe” setting of the segment descriptor “TAXi optimizedload” bit discussed in section VIII.A, supra.

The implementation of this feature somewhat parallels the mechanism usedfor branch prediction. Recall that converter 134, 136 decomposes eachX86 instruction into a plurality of native Tapestry RISC instructionsfor execution by Tapestry pipeline 120. When a single X86 instructionhas several memory references, each memory reference is isolated into adiscrete Tapestry instruction. Even though the Zero/non-Zero ASI valueis recorded in the D-TLB, and thus can be determined without actuallyinitiating a bus cycle, the address space resolution occurs relativelylate in the pipeline. Thus, when a reference to a non-zero ASI isdetected, the Tapestry instructions following the load in the pipelineare flushed.

TAXi_State.Event_Code_Latch 486, 487 (see section V.E, infra) is updatedwith the special I/O load converter event code 1.1100 of FIG. 4 b. ATAXi instruction to record the I/O space profile entry is injected, andthe normal profile collection hardware then records an “I/O space load”profile entry, in the manner discussed in connection with FIGS. 5 a and5 b in section V.F, supra. Note that this TAXi instruction may beinjected in the middle of the recipe for a single X86 instruction, wherethe other TAXi instructions discussed in section V.F are injected at X86instruction boundaries. Normal X86 instruction execution resumes inconverter 136, and the remainder of the instructions in the converterrecipe are reinitiated.

Alternative embodiments might select other classes of instructions forprofiling, typically those instructions that have a high likelihood ofraising a synchronous exception, or that have some other property ofinterest to hot spot detector 122 or TAXi translator 124. The number ofsuch profiled instructions is kept relatively small, so as not tosubstantially reduce the density of the information made available tohot spot detector 122 or TAXi translator 124.

C. Reconstructing Canonical Machine State to Arrive at a PreciseBoundary

The code generated by TAXi translator 124 is annotated with informationthat allows the recovery of X86 instruction boundaries. If a single X86instruction is decomposed into many Tapestry instructions, and thoseTapestry instructions are reordered by the TAXi optimizer, then theannotation allows the end of particular X86 instructions to beidentified. The information stored is similar to that emitted byoptimizing compilers for use by debuggers. There, the instructions of asingle source statement are annotated so that source statements can berecovered. In TAXi, the annotation allows the recovery of X86instruction boundaries from a tangled web of Tapestry instructions.Thus, when a synchronous exception is to be exposed to the virtual X86,the TAXi run time system establishes a system state equivalent to thatwhich would prevail at an X86 instruction boundary. Once state isrestored to a precise instruction boundary, execution can be tendered toconverter 136, which in turn can resume execution from that instructionboundary.

In some instances, this annotation mechanism may roll back execution bya considerable number of instructions, in order to establish a “safe”state, where all X86 instructions can either be assumed to have notstarted, or completed completely. The rollback mechanism avoids resumingexecution from a state where a single side-effect may be applied twice.

The code may “checkpoint” itself, capturing a self-consistent statesnapshot somewhat in the manner of a database system. Then, in the eventof a fault in the TAXi code, execution can be rolled back to thecheckpoint, and resumed in converter 136.

D. Safety Net Execution

Referring again to FIG. 3 j, in one alternative embodiment, if this isan asynchronous interrupt, case 351 or 354 can allow X86 emulator 316 orconverter 136, respectively, to progress forward to the next X86instruction boundary, before delivering the interrupt. In anotheralternative embodiment, case 354 can roll back X86 emulator 316 to theprevious X86 instruction boundary. After state is secured to an X86boundary, execution proceeds through X86 operating system 306 as in case351. In other alternative embodiments, in the case of asynchronousinterrupts in cases 351, 353, and 354, the code can be allowed toprogress forward to the next safety net checkpoint before delivering theexception. Each of these are conceptually similar, in that the virtualX86 310 is “brought to rest” at a stable point at which all Tapestryextended context is dead and discardable, and only events whose order isnot guaranteed by the X86 architecture are allowed to be reordered withrespect to each other.

When an exception occurs in TAXi code and the exception handlerdetermines that it must materialize the exception in the x86 virtualmachine, it jumps to a common entry in emulator 316 that is responsiblefor setting the x86 state—establishing the interrupt stack frame,accessing the IDT and performing the control transfer. When thisfunction is invoked, it must first determine if TAXi code was beingexecuted by examining PSW.TAXi_Active and if so jump to a TAXi functionthat reconstructs the X86 machine state and then re-executes the X86instruction in the converter to provoke the same exception again.Re-executing the X86 instruction establishes the correct X86 exceptionstate. Anytime the converter is started to re-execute an x86instruction, the exception handler uses the RFE with probe failed,reload probe timer event code to prevent a recursive probe exceptionfrom occurring.

The only exceptions that may not be exposed to the X86 are those thatcan be completely executed by native Tapestry code, e.g. TLB miss thatis satisfied without a page fault, FP incomplete with no unmasked x86floating-point exceptions, etc.

IX. Interrupt Priority

The TAXi system uses five exceptions, and one software trap. DMU 700introduces one new interrupt sub-case. These interrupts are summarizedin the following table 7:

TABLE 7 name description type priority discussion VECT_TAXi_UNPROTECTEDstarting profile on a TAXi note 1 4.0 I.F unprotected pageVECT_TAXi_PROBE probe for translated code note 2 4.1 VI exceptionVECT_TAXi_PROFILE profile packet complete note 2 4.2 V exceptionVECT_TAXi_PROTECTED writing to a TAXi protected fault 5.4 I.F pageVECT_TAXi_IO read from (ASI != 0) in fault 5.5 VIII.A translated codeVECT_TAXi_EXIT restart converter on TAXi software 2.4 VI.F codecompletion trap DMU_INVALIDATE DMU invalidation event interrupt 2.0 VIInote 1. This fault is raised on the first native instruction in an X86converter recipe. note 2. This fault is raised as a trap on the TAXiinstruction, i.e. the TAXi instruction completes writing its data to theGPR.

To achieve performance, TAXi code does not keep X86 state in thecanonical locations assumed by converter 136 and emulator 316.Therefore, when TAXi code is interrupted, the converter is not allowedto resume without first recovering the canonical picture of the X86machine's state.

The exception strategy described supra is intended to achievecorrectness through simplicity, to have a single common strategy forprocessing all exceptions, to ensure that exceptions raised in TAXi codeare processed by exactly the same code as exceptions raised by theconverter, to maximize performance, to delay abandoning TAXi code untilit is known that an exception must be surfaced to the X86, and to allowTAXi code to forego maintaining the X86 FP exception state.

For the convenience of the reader, the above description has focused ona representative sample of all possible embodiments, a sample thatteaches the principles of the invention and conveys the best modecontemplated for carrying it out. The description has not attempted toexhaustively enumerate all possible variations. Further undescribedalternative embodiments are possible. It will be appreciated that manyof those undescribed embodiments are within the literal scope of thefollowing claims, and others are equivalent.

The following volumes are incorporated by reference. Intel ArchitectureSoftware Developer's Manual, vol. 1-3, Intel Corp. (1997); Gerry Kane,PA-RISC 2.0 Architecture, Hewlett-Packard Professional Books,Prentice-Hall (1996); Richard L. Sites and Richard T. Witek, The AlphaAXP Architecture Reference Manual, 2d ed., Digital Press, Boston (1995);David A. Patterson and John L. Hennessey, Computer Architecture: AQuantative Approach, Morgan Kaufman Publ., San Mateo, Calif. (1990);Timothy Leonard, ed., Vax Architecture Reference Manual, DigitalEquipment Corp. (1987); Peter M. Kogge, The Architecture of PipelinedComputers, Hemisphere Publ., McGraw Hill (1981); John Mick and JamesBrick, Bit-slice Microprocessor Design, McGraw-Hill (1980).

1. A microprocessor chip, comprising: instruction pipeline circuitry;and table lookup circuitry designed to retrieve an entry from a table,each entry of the table being associated with a corresponding addressrange translated by address translation circuitry of the microprocessorchip, each entry describing a likelihood of the existence of analternate coding of instructions located in the respective correspondingaddress range, the table lookup circuitry operable as part of the basicinstruction cycle of executing an instruction of a non-supervisor modeprogram executing on a computer; interrupt circuitry cooperativelydesigned with the instruction pipeline circuitry to synchronouslytrigger an interrupt in accordance with interrupt criteria on executionof an instruction of a process, wherein the architectural definition ofthe instruction does not call for an interrupt, the interrupt criteriabeing based at least in part on the table entry associated with theaddress of the instruction, the interrupt circuitry being designed toinvoke a handler for the interrupt, the handler being responsive to acontent of the table entry to affect the instruction pipeline circuitryto effect control of an architecturally-visible data manipulationbehavior or control transfer behavior of the instruction based on thecontents of a table entry associated with the address range in which theinstruction lies.
 2. A method, comprising the steps of: as part of thebasic instruction cycle of executing an instruction of a non-supervisormode program executing on a computer, consulting a table, the tablehaving entries that are indexed by the address within an address spaceof instructions executed, entries of the table containing attributes ofinstructions whose addresses index to the respective table entries; andcontrolling an architecturally-visible data manipulation behavior orcontrol transfer behavior of the instruction based at least in part on acontent of a table entry indexed by the address of the instruction. 3.The method of claim 2, wherein the control of control transfer behaviorincludes transfer of execution control to a second instruction forexecution, the second instruction being an instruction other than aninstruction architecturally-defined to be the successor instruction ofthe instruction.
 4. The method of claim 3, wherein the secondinstruction is coded in an instruction set architecture (ISA) differentthan the ISA of the executed instruction.
 5. The method of claim 2,wherein the control of architecturally-visible data manipulationbehavior includes changing an instruction set architecture under whichinstructions are interpreted by the computer.
 6. The method of claim 2,wherein the behavior control includes selecting between two differentinstruction set architectures, and the computer includes instructionpipeline circuitry designed to effect interpretation of computerinstructions under the two instruction set architectures alternately. 7.The method of claim 2, wherein: entries of the table describe alikelihood of the existence of an alternate coding of instructionslocated in respective corresponding address ranges.
 8. The method ofclaim 2, wherein: entries of the table correspond to pages managed by avirtual memory manager, and wherein circuitry for locating an entry ofthe table is integrated with virtual memory address translationcircuitry of the computer.
 9. The method of claim 2, further comprisingthe steps of: triggering a synchronous interrupt on execution of theinstruction based at least in part on a memory state of the computer andthe address of the instruction, wherein the architectural definition ofthe instruction in the instruction's native architecture does not callfor an interrupt.
 10. The method of claim 9, wherein a portion of thememory state relevant to the interrupt trigger includes a content of thetable entry indexed by the address of the instruction, wherein thearchitectural definition of the instruction does not call for aninterrupt.
 11. The method of claim 2, wherein the table entry indexed bythe address of the instruction is associated with a range of instructionaddresses.
 12. The method of claim 2, wherein: the controlling ofinstruction behavior includes altering a manipulation of data or controltransfer behavior of the instruction in a manner incompatible with thearchitectural definition of the instruction in the instruction's nativearchitecture.
 13. The method of claim 2, wherein: the step of consultingthe table as part of executing an instruction is performed as part offetching the instruction.
 14. A microprocessor chip, comprising:instruction pipeline circuitry; table lookup circuitry designed to indexinto a table by a memory address of a memory reference arising duringexecution of an architecturally-defined instruction, and to retrieve atable entry corresponding to the address, the table entry being distinctfrom the memory referenced by the memory reference; the instructionpipeline circuitry being responsive to the contents of the table entryto alter a manipulation of data or control transfer behavior of theinstruction in a manner incompatible with the architectural definitionof the instruction in the instruction's native architecture.
 15. Themicroprocessor chip of claim 14, further comprising: a binary translatorprogrammed to translate at least a selected portion of a computerprogram from a first binary representation to a second binaryrepresentation; and wherein the pipeline control circuitry is furtherdesigned to initiate a determination of whether to transfer control froman execution of the architecturally-defined instruction, thearchitecturally-defined instruction being an instruction of the firstbinary representation of the program, to the second binaryrepresentation, and effective to initiate the determination with neithera query nor a control transfer to the second binary representation beingcoded into the first binary representation.
 16. The microprocessor chipof claim 14, further comprising: interrupt circuitry cooperativelydesigned with the instruction pipeline circuitry to trigger asynchronous interrupt on execution of the architecturally-definedinstruction based at least in part on the contents of the table entry,wherein the architectural definition of the architecturally-definedinstruction in the instruction's native architecture does not call foran interrupt.
 17. The microprocessor chip of claim 16, furthercomprising: interrupt handler software designed to service the interruptand to effect the altering of a control transfer behavior, the alteringbeing in the form of returning control from the handler to aninstruction flow other than the instruction flow triggering theinterrupt, the returned-to instruction flow for carrying on non-errorhandling normal processing logically equivalent to thearchitecturally-defined processing of instructions following the alteredinstruction.
 18. A microprocessor chip, comprising: instruction pipelinecircuitry; address translation circuitry; and a lookup structure havingentries associated with corresponding address ranges generated by theinstruction pipeline circuitry and translated by the address translationcircuitry, the entries describing a likelihood of the existence of analternate coding of instructions located in the respective correspondingaddress range.
 19. The microprocessor chip of claim 18, wherein theentry is an entry of a translation look-aside buffer.
 20. Themicroprocessor chip of claim 18, wherein the alternate coding is codedin an instruction set architecture (ISA) different than the ISA of theinstruction located in the address range.
 21. The microprocessor chip ofclaim 18, wherein: the instruction pipeline circuitry is responsive tothe contents of the lookup structure entry to affect anarchitecturally-visible manipulation of data or control transferbehavior of the instruction.
 22. The microprocessor chip of claim 18,further comprising: interrupt circuitry cooperatively designed with theinstruction pipeline circuitry to trigger a synchronous interrupt onexecution of an instruction of a process based at least in part on alookup structure entry associated with the address of the instruction,wherein the architectural definition of the instruction in theinstruction's native architecture does not call for an interrupt.
 23. Amicroprocessor chip, comprising: instruction pipeline circuitry; andinterrupt circuitry cooperatively designed with the instruction pipelinecircuitry to trigger a synchronous interrupt on execution of aninstruction of a process based at least in part on a memory state of thecomputer and the address of the instruction, wherein the architecturaldefinition of the instruction in the instruction's native architecturedoes not call for an interrupt.
 24. The microprocessor chip of claim 23,further comprising: interrupt handler software designed to service theinterrupt and to return control to an instruction flow of the processother than the instruction flow triggering the interrupt, thereturned-to instruction flow for carrying on non-error handling normalprocessing of the process.
 25. The microprocessor chip of claim 24,wherein the interrupt handler software is programmed to change aninstruction set architecture under which instructions are interpreted bythe computer.
 26. The microprocessor chip of claim 24, wherein thereturned-to instruction flow is logically equivalent to the instructionflow beginning at the interrupted instruction.
 27. The microprocessorchip of claim 23, further comprising: table lookup circuitry designed toindex into a table by a memory address within an address space of amemory reference arising during execution of the instruction, and toretrieve a table entry corresponding to the memory-reference address;the instruction pipeline circuitry being responsive to the contents ofthe table entry to affect an architecturally-visible manipulation ofdata or control transfer behavior of the instruction.
 28. Themicroprocessor chip of claim 23, wherein a trigger for the interrupt isfurther based on a value of the instruction.
 29. The microprocessor chipof claim 23, wherein: the memory state on which triggering the interruptis based includes an entry of a table indexed by the address ofinstructions fetched for execution, entries of the table containingattribute indicia of instructions whose addresses index to therespective entries, the table entries being architecturally invisible toan architecture for execution in the instruction pipeline circuitry. 30.A method, comprising the steps of: as an integral part of processing aninstruction in instruction pipeline circuitry of a computer, consultinga lookup structure of entries, entries of the lookup structurecorresponding to address ranges translated by address translationcircuitry, and the entries describe a likelihood of the existence of analternate coding of instructions located in the respective correspondingaddress ranges.
 31. The method of claim 30, further comprising the stepof: altering a behavior of the instruction in a manner incompatible withthe architectural definition of the instruction in the instruction'snative architecture, based at least in part on a content of the lookupstructure entry corresponding to the address range containing theinstruction.
 32. The method of claim 30, wherein each lookup structureentry corresponds to a page managed by a virtual memory manager, andwherein circuitry for locating a lookup structure entry is integratedwith virtual memory address translation circuitry of the computer. 33.The method of claim 30, further comprising the step of: based at leastin part on a content of the lookup structure entry, transferring controlto the alternative coding, the alternative coding being an instructionflow of the process other than the instruction flow triggering theconsulting, the transferred-to instruction flow being programmed tocarry on non-error handling normal processing of the process.
 34. Themethod of claim 30, further comprising the step of: based at least inpart on a content of the lookup structure entry, triggering asynchronous interrupt, wherein the architectural definition of theinstruction in the instruction's native architecture does not call foran interrupt.
 35. The method of claim 30, further comprising the stepof: after determining that the existence of an alternate coding islikely, consulting a second table, the entries of the second tabledefinitively indicating entry points for initiating such alternatecodings as exist.
 36. The method of claim 30, wherein: the lookupstructure entries are architecturally invisible to programs executing inan instruction set architecture executed by the instruction pipelinecircuitry.
 37. A method, comprising the steps of: as an integral part ofprocessing an instruction in instruction pipeline circuitry of acomputer, consulting a lookup structure of entries, each entrycorresponding to an address range translated by address translationcircuitry, and describing a likelihood of the existence of an alternatecoding of instructions located in the respective corresponding addressrange; and as a result of the consulting, changing an instruction setarchitecture under which instructions are interpreted by the computer.38. A method, comprising the steps of: on execution of an instruction ofa process in a computer, triggering a synchronous interrupt based atleast in part on a memory state of the computer and the address of theinstruction, wherein the architectural definition of the instruction inthe instruction's native architecture does not call for an interrupt.39. The method of claim 38, further comprising the step of: servicingthe interrupt and returning control to an instruction flow of theprocess other than the instruction flow triggering the interrupt, thereturned-to instruction flow being programmed to carry on non-errorhandling normal processing of the process.
 40. The method of claim 39,further comprising the step of: the changing an instruction setarchitecture under which instructions are interpreted by the computer inhandler software for the interrupt.
 41. The method of claim 40, whereinthe instruction text beginning at the returned-to instruction islogically equivalent to the instruction text beginning at theinterrupted instruction.
 42. The method of claim 38, further comprising:indexing into a table by a memory, address within an address space of amemory reference arising during execution of an instruction, and toretrieve a table entry corresponding to the address; responding to acontent of the table entry to affect an architecturally-visiblemanipulation of data or control transfer behavior of the instruction.43. A method, comprising the steps of: as part of the basic instructioncycle of executing an architecturally-defined instruction of anon-supervisor mode program executing on a computer, retrieving an entryfrom a table, the table entry being indexed by the address of a memoryreference arising during execution of the architecturally-definedinstruction, the table entry being distinct from the memory referencedby the memory reference; based at least in part on a content of thetable entry, altering a manipulation of data or control transferbehavior of the architecturally-defined instruction in a mannerincompatible with the architectural definition of thearchitecturally-defined instruction in the architecturally-definedinstruction's native architecture.
 44. The method of claim 43, whereinthe entries of the table correspond to ranges of memory addresses. 45.The method of claim 43, wherein the table entry is indexed by theaddress within an address space of instructions fetched for execution.46. The method of claim 43, wherein: entries of the table correspond torespective address ranges, and the table entries describe a likelihoodof the existence of an alternate coding of instructions located in therespective corresponding address ranges.
 47. The method of claim 43:wherein the architectural definition of the architecturally-definedinstruction in the architecturally-defined instruction's nativearchitecture does not call for an interrupt; and further comprising thestep of triggering a synchronous interrupt based at least in part on amemory state of the computer and the address of thearchitecturally-defined instruction.
 48. The method of claim 43, whereinthe control of control transfer behavior includes transfer of executioncontrol to a second instruction for execution.
 49. The method of claim48, wherein the second instruction is coded in an instruction setarchitecture (ISA), different than the ISA of thearchitecturally-defined instruction.
 50. The method of claim 43, whereinthe control of architecturally-visible data manipulation behaviorincludes changing an instruction set architecture under whichinstructions are interpreted by the computer.
 51. The method of claim43, wherein the behavior control includes selecting between twodifferent instruction set architectures, and the computer includesinstruction pipeline circuitry designed to effect interpretation ofcomputer instructions under the two instruction set architecturesalternately.
 52. The method of claim 43: wherein each entry of the tablecorresponds to a page managed by a virtual memory manager, and whereincircuitry for locating an entry of the table is integrated with virtualmemory address translation circuitry of the computer.
 53. An apparatus,comprising: instruction pipeline circuitry; and table lookup circuitrydesigned to retrieve a table entry from a table whose entries areindexed by an address within an address space of an instruction fetchedfor execution by the instruction pipeline circuitry; the instructionpipeline circuitry being responsive to a content of the table entry tocontrol an architecturally-visible data manipulation behavior or controltransfer behavior of the fetched instruction based at least in part on acontent of the table entry indexed by the address of the instruction.54. The apparatus of claim 53, wherein the control of control transferbehavior includes transfer of execution control to a second instructionfor execution, the second instruction being coded in an instruction setarchitecture (ISA) different than the ISA of the executed instruction.55. The apparatus of claim 53, wherein entries of the table correspondto pages managed by a virtual memory manager, circuitry for locating atable entry being integrated with virtual memory address translationcircuitry of the computer.
 56. The apparatus of claim 53, wherein: thetable entry is stored in storage architecturally invisible to programsexecuting in the instruction's native architecture.
 57. The apparatus ofclaim 53, further comprising: circuitry designed to trigger asynchronous interrupt on execution of an instruction of a process, basedat least in part on a memory state of the computer and the address ofthe instruction, wherein the architectural definition of the instructionin the instruction's native architecture does not call for an interrupt.58. The apparatus of claim 53, wherein: the table entries are indexed bya virtual address of the instruction.
 59. The apparatus of claim 53,wherein: the table entries are indexed by a physical address of theinstruction.
 60. A method, comprising the steps of: as part of the basicinstruction cycle of executing an instruction of a non-supervisor modeprogram fetched for execution on a computer, consulting a table, entriesof the table being indexed by addresses of instructions fetched, entriesof the table containing attribute indicia of instructions whoseaddresses index to the respective entries; and controlling anarchitecturally-visible data manipulation behavior or control transferbehavior of the fetched instruction based at least in part on a contentof a table entry indexed by the address of the fetched instruction, thetable entries being architecturally-invisible in the fetchedinstruction's native architecture.
 61. The method of claim 60, whereinthe control of control transfer behavior includes transfer of executioncontrol to a second instruction for execution, the second instructionbeing an instruction other than an instruction architecturally-definedto be the successor instruction of the fetched instruction.
 62. Themethod of claim 61, wherein the second instruction is coded in aninstruction set architecture (ISA) different than the ISA of the fetchedinstruction.
 63. The method of claim 60, wherein the control ofarchitecturally-visible data manipulation behavior includes changing aninstruction set architecture under which instructions are interpreted bythe computer.
 64. The method of claim 60, wherein the behavior controlincludes selecting between two different instruction set architectures,and the computer includes instruction pipeline circuitry designed toeffect interpretation of computer instructions under the two instructionset architectures alternately.
 65. The method of claim 60, wherein: theattribute indicia describe a likelihood of the existence of an alternatecoding of instructions located in respective address rangescorresponding to the table entries.
 66. The method of claim 60: whereinthe architectural definition of the fetched instruction in the fetchedinstruction's native architecture does not call for an interrupt; andfurther comprising the step of triggering a synchronous interrupt basedat least in part on a memory state of the computer and the address ofthe fetched instruction.
 67. The method of claim 60, further comprisingthe step of: altering a behavior of the fetched instruction in a mannerincompatible with the architectural definition of the fetchedinstruction in the fetched instruction's native architecture, based atleast in part on a content of the table entry indexed by the address ofthe fetched instruction.
 68. The method of claim 60, wherein: entries ofthe table correspond to pages managed by a virtual memory manager, andwherein circuitry for locating an entry of the table is integrated withvirtual memory address translation circuitry of the computer.
 69. Anapparatus, comprising: instruction pipeline circuitry; and table lookupcircuitry designed to retrieve a table entry from a table whose entriesare indexed by an address of an instruction fetched for execution, thetable being stored in storage that is architecturally invisible toprograms in the fetched instruction's native architecture; theinstruction pipeline circuitry being responsive to a content of thetable entry to control an architecturally-visible data manipulationbehavior or control transfer behavior of the fetched instruction basedat least in part on a content of the table entry associated with theaddress of the fetched instruction.
 70. The apparatus of claim 69,wherein the control of control transfer behavior includes transfer ofexecution control to a second instruction for execution, the secondinstruction being coded in an instruction set architecture (ISA)different than the ISA of the fetched instruction.
 71. The apparatus ofclaim 69, wherein entries of the table correspond to pages managed by avirtual memory manager, the table lookup circuitry being integrated withvirtual memory address translation circuitry.
 72. The apparatus of claim69, wherein: entries of the table describe a likelihood of the existenceof an alternate coding of instructions located in address rangescorresponding to respective table entries.
 73. The apparatus of claim69, wherein: the control of the fetched instruction's behavior includesaltering a manipulation of data or control transfer behavior of thefetched instruction in a manner incompatible with the architecturaldefinition of the fetched instruction in the fetched instruction'snative architecture.
 74. The apparatus of claim 69, further comprisingthe steps of: triggering a synchronous interrupt on fetch or executionof the fetched instruction, based at least in part on a memory state ofthe computer and the address of the fetched instruction, wherein thearchitectural definition of the fetched instruction in the fetchedinstruction's native architecture does not call for an interrupt. 75.The apparatus of claim 69, wherein: the table entries are indexed byvirtual addresses of instructions.
 76. The apparatus of claim 69,wherein: the table entries are indexed by physical addresses ofinstructions.
 77. A microprocessor chip, comprising: instructionpipeline circuitry; and table lookup circuitry designed to retrieve anentry from a table, each entry of the table being associated with acorresponding address range of an address space translated by addresstranslation circuitry of the microprocessor chip, each entry describinga likelihood of the existence of an alternate coding of instructionslocated in the respective corresponding address range, the table lookupcircuitry operable as part of the basic instruction cycle of executingan instruction of a non-supervisor mode program for execution on themicroprocessor chip, the table being stored in storage that isarchitecturally invisible to programs in the native architecture of atleast some instructions executed by the microprocessor chip; interruptcircuitry cooperatively designed with the instruction pipeline circuitryto trigger a synchronous interrupt on execution of an instruction of aprocess, wherein the architectural definition of the instruction of theprocess does not call for an interrupt, a trigger for the interruptbeing synchronously based at least in part on the table entrycorresponding to the address of the instruction of the process, theinterrupt circuitry being designed to invoke a handler for theinterrupt, the handler being responsive to a content of the table entryto affect the instruction pipeline circuitry to effect control of anarchitecturally-visible data manipulation behavior or control transferbehavior of the instruction of the process, based at least in part onthe contents of a table entry corresponding to the address range inwhich the instruction of the process lies.